一个程序明白buddy算法

时间：2015-01-31 14:48:13 阅读：276 评论：0 收藏：0 [点我收藏+]

#define method 2

#if method == 0x00
#include<stdio.h>
#include<math.h>

/*
* struct array_cache
*
* Per cpu structures
* Purpose:
* - LIFO ordering, to hand out cache-warm objects from _alloc
* - reduce the number of linked list operations
* - reduce spinlock operations
*
* The limit is stored in the per-cpu structure to reduce the data cache
* footprint.
*
*/
/**
* 空闲对象的本地高速缓存描述符（注意：是描述符而不是本地高速缓存本身，本地高速缓存在描述符后面）
*/
struct array_cache {
/**
* 指向本地高速缓存中可使用对象的指针的个数。
* 它同时也作为高速缓存中第一个空槽的下标。
*/
unsigned int avail;
/**
* 本地高速缓存的大小，也就是本地高速缓存中指针的最大个数
*/
unsigned int limit;
/**
* 本地高速缓存重新填充或者腾空时使用的块大小
*/
unsigned int batchcount;
/**
* 如果最近被使用过，则置为1
*/
unsigned int touched;
};

/* bootstrap: The caches do not work without cpuarrays anymore,
* but the cpuarrays are allocated from the generic caches...
*/
#define BOOT_CPUCACHE_ENTRIES 1
struct arraycache_init {
struct array_cache cache;
void * entries[BOOT_CPUCACHE_ENTRIES];
};

static struct arraycache_init initarray_cache =
{ { 0, BOOT_CPUCACHE_ENTRIES, 1, 0},{(void *) 0x11} };
static struct arraycache_init initarray_generic =
{ { 0, BOOT_CPUCACHE_ENTRIES, 1, 0} };

int main()
{
printf("sizeof(struct array_cache) = %d.\r\n", sizeof(struct array_cache) );
printf("sizeof(initarray_generic) = %d.\r\n", sizeof(initarray_generic) );

return 0;
}

#elif method == 0x01

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>

static int fixsize( int size );

struct buddy2 {
unsigned size;
unsigned longest[1];
};

#define LEFT_LEAF(index) ((index) * 2 + 1)
#define RIGHT_LEAF(index) ((index) * 2 + 2)
#define PARENT(index) ( ((index) + 1) / 2 - 1)

#define IS_POWER_OF_2(x) (!((x)&((x)-1)))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

#define ALLOC malloc
#define FREE free

//#define IS_POWER_OF_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))

struct buddy2* buddy2_new( int size ) {
struct buddy2* self;
unsigned node_size;
int i;

if (size < 1 || !IS_POWER_OF_2(size))
return NULL;

self = (struct buddy2*)ALLOC( 2 * size * sizeof(unsigned));
self->size = size;
node_size = size * 2;

for (i = 0; i < 2 * size - 1; ++i) {
if (IS_POWER_OF_2(i+1))
node_size /= 2;
self->longest[i] = node_size;
}
return self;
}

int buddy2_alloc(struct buddy2* self, int size) {
unsigned index = 0;
unsigned node_size;
unsigned offset = 0;

if (self==NULL)
return -1;

if (size <= 0)
size = 1;
else if (!IS_POWER_OF_2(size))
size = fixsize(size);

if (self->longest[index] < size)
return -1;

for(node_size = self->size; node_size != size; node_size /= 2 ) {
if (self->longest[LEFT_LEAF(index)] >= size)
index = LEFT_LEAF(index);
else
index = RIGHT_LEAF(index);
}

self->longest[index] = 0;
offset = (index + 1) * node_size - self->size;

while (index) {
index = PARENT(index);
self->longest[index] =
MAX(self->longest[LEFT_LEAF(index)], self->longest[RIGHT_LEAF(index)]);
}

return offset;
}

void buddy2_free(struct buddy2* self, int offset) {
unsigned node_size, index = 0;
unsigned left_longest, right_longest;

//assert(self && offset >= 0 && offset < size);

node_size = 1;
index = offset + self->size - 1;

for (; self->longest[index] ; index = PARENT(index)) {
node_size *= 2;
if (index == 0)
return;
}

self->longest[index] = node_size;

while (index) {
index = PARENT(index);
node_size *= 2;

left_longest = self->longest[LEFT_LEAF(index)];
right_longest = self->longest[RIGHT_LEAF(index)];

if (left_longest + right_longest == node_size)
self->longest[index] = node_size;
else
self->longest[index] = MAX(left_longest, right_longest);
}
}

#ifndef __BUDDY2_H__
#define __BUDDY2_H__

#include <stdlib.h>

struct buddy2;
struct buddy2* buddy2_new( int size );
void buddy2_destroy( struct buddy2* self );

int buddy2_alloc(struct buddy2* self, int size);
void buddy2_free(struct buddy2* self, int offset);

int buddy2_size(struct buddy2* self, int offset);
void buddy2_dump(struct buddy2* self);

#endif//__BUDDY2_H__

static int fixsize( int size )
{
size |= size >> 1;
size |= size >> 2;
size |= size >> 4;
size |= size >> 8;
size |= size >> 16;
return size+1;
}

void buddy2_destroy( struct buddy2* self) {
FREE(self);
}

int buddy2_size(struct buddy2* self, int offset) {
unsigned node_size, index = 0;

assert(self && offset >= 0 && offset < self->size);

node_size = 1;
for (index = offset + self->size - 1; self->longest[index] ; index = PARENT(index))
node_size *= 2;

return node_size;
}

void buddy2_dump(struct buddy2* self) {
char canvas[65];
int i,j;
unsigned node_size, offset;

if (self == NULL) {
printf("buddy2_dump: (struct buddy2*)self == NULL");
return;
}

if (self->size > 64) {
printf("buddy2_dump: (struct buddy2*)self is too big to dump");
return;
}

memset(canvas,‘_‘, sizeof(canvas));
node_size = self->size * 2;

for (i = 0; i < 2 * self->size - 1; ++i) {
if ( IS_POWER_OF_2(i+1) )
node_size /= 2;

if ( self->longest[i] == 0 ) {
if (i >= self->size - 1) {
canvas[i - self->size + 1] = ‘*‘;
}
else if (self->longest[LEFT_LEAF(i)] && self->longest[RIGHT_LEAF(i)]) {
offset = (i+1) * node_size - self->size;

for (j = offset; j < offset + node_size; ++j)
canvas[j] = ‘*‘;
}
}
}
canvas[self->size] = ‘\0‘;
puts(canvas);
}

//#include "buddy2.h"
#include <stdio.h>
int main() {
char cmd[80];
int arg;
struct buddy2* buddy = buddy2_new(32);
buddy2_dump(buddy);
for (;;) {
scanf("%s %d", cmd, &arg);
if (strcmp(cmd, "alloc") == 0) {
printf("allocated@%d\n", buddy2_alloc(buddy, arg));
buddy2_dump(buddy);
} else if (strcmp(cmd, "free") == 0) {
buddy2_free(buddy, arg);
buddy2_dump(buddy);
} else if (strcmp(cmd, "size") == 0) {
printf("size: %d\n", buddy2_size(buddy, arg));
buddy2_dump(buddy);
} else
buddy2_dump(buddy);
}
}

////////////////////////////////////////////////////////////////
#elif method == 0x02
//start from here
#ifndef BUDDY_MEMORY_ALLOCATION_H
#define BUDDY_MEMORY_ALLOCATION_H

struct buddy;

struct buddy * buddy_new(int level);
void buddy_delete(struct buddy *);
int buddy_alloc(struct buddy *, int size);
void buddy_free(struct buddy *, int offset);
int buddy_size(struct buddy *, int offset);
void buddy_dump(struct buddy *);
#endif

//#include "buddy.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>

#define NODE_UNUSED 0
#define NODE_USED 1
#define NODE_SPLIT 2
#define NODE_FULL 3

struct buddy {
int level;
uint8_t tree[1];
};

struct buddy * buddy_new( int level )
{
int size = 1 << level;
//printf( "level = %d.\r\n", level );
//printf( "size = %d.\r\n", size );
//printf( "sizeof(struct buddy) = %d.\r\n", sizeof(struct buddy) );
//printf( "sizeof(uint8_t) = %d.\r\n", sizeof(uint8_t) );
struct buddy *self = malloc(sizeof(struct buddy) + sizeof(uint8_t) * (size * 2 - 2));
//printf( "(sizeof(struct buddy) + sizeof(uint8_t) * (size * 2 - 2)) = %d.\r\n", (sizeof(struct buddy) + sizeof(uint8_t) * (size * 2 - 2)) );

//printf( "self = 0x%x.\r\n", self );
self->level = level;
//printf( "self->level = 0x%x.\r\n", self->level );
//printf( "&self->level = 0x%x.\r\n", &self->level );
//printf( "&self->tree = 0x%x.\r\n", &self->tree );
//printf( "self->tree = 0x%x.\r\n", self->tree );
memset( self->tree, NODE_UNUSED, size*2-1 );
return self;
}

void buddy_delete( struct buddy * self )
{
free(self);
}

//inline
static int is_pow_of_2( uint32_t x )
{
return !(x & (x-1));
}
//看一个数是否是2的power,2的n次幂
//即0 1 2 4 8 16 32 64 ...

//inline
static uint32_t next_pow_of_2( uint32_t x )
{
if( is_pow_of_2(x) ){
return x;
}
x |= x>>1;
x |= x>>2;
x |= x>>4;
x |= x>>8;
x |= x>>16;
return x+1;
}

//static inline int _index_offset(int index, int level, int max_level)
//为运行效率计,用inline,为调试方便计,去除inline
static int _index_offset( int index, int level, int max_level )
{
unsigned int ret;

//printf( "index = %d.\r\n", index );
//printf( "level = %d.\r\n", level );
//printf( "max_level = %d.\r\n", max_level );
ret = ((index + 1) - (1 << level)) << (max_level - level);

//printf( "ret = %d.\r\n", ret );
return ret;
}

//标记父母函数
static void _mark_parent( struct buddy * self, int index )
{
for( ; ; ){
//printf( "index = %d.\r\n", index );
int buddy = index - 1 + (index & 1) * 2;
//printf( "buddy = %d.\r\n", buddy );
//找出自己的兄弟
if( buddy > 0 && (self->tree[buddy] == NODE_USED || self->tree[buddy] == NODE_FULL) ){
//不是根节点并且兄弟节点使用了或者兄弟节点满了
//那么就要标记父亲节点
index = (index + 1) / 2 - 1;
//找到父亲节点的索引号
self->tree[index] = NODE_FULL;
//父亲节点置为满
}else{
//否则,还没满,不用管,维持原状就好了
return;
}
}
}

int buddy_alloc( struct buddy * self, int s )
{
int size, length, index, level;
if( s == 0 ){
size = 1;
}else{
size = (int)next_pow_of_2(s);
}
length = 1 << self->level;
if( size > length ){
return -1;
}

index = 0;
level = 0;
//printf( "size = %d.\r\n", size );
//printf( "length = %d.\r\n", length );
while( index >= 0 ){
if( size == length ){
//printf( "index.2 = %d.\r\n", index );
//printf( "self.2 = 0x%x.\r\n", self );
if( self->tree[index] == NODE_UNUSED ){
self->tree[index] = NODE_USED;
_mark_parent(self, index);
return _index_offset(index, level, self->level);
}
}else{
//size < length
switch( self->tree[index] )
{
case NODE_USED:
case NODE_FULL:
//已经使用或者已经满了
break;
case NODE_UNUSED:
//split first
//第一步裂开前提是父节点没有被使用才可以裂开
self->tree[index] = NODE_SPLIT;
//父节点置为裂开状态 (2)
self->tree[index*2+1] = NODE_UNUSED;
//左孩子置为未使用状态 (0)
self->tree[index*2+2] = NODE_UNUSED;
//右孩子置为未使用状态 (0)
//printf( "index.0 = %d.\r\n", index );
//printf( "self = 0x%x.\r\n", self );
//printf( "self->tree[index] = %d.\r\n", self->tree[index] );
//printf( "&self->tree[index] = 0x%x.\r\n", &self->tree[index] );
//printf( "self->tree[index] = %d.\r\n", self->tree[index*2+1] );
//printf( "self->tree[index] = %d.\r\n", self->tree[index*2+2] );
//注意没有break
default:
index = index * 2 + 1;
//索引指向左孩子
length /= 2;
//长度缩小一半
level++;
//搜索层级加1 即指向下一层
//printf( "index.1 = %d.\r\n", index );
//printf( "length = %d.\r\n", length );
//printf( "level = %d.\r\n", level );
continue;
//注意没有break
}
}
//printf( "index.2 = %d.\r\n", index );
if( index & 1 ){
++index;
continue;
}
for( ; ; ){
printf( "index.2 = %d.\r\n", index );
level--;
length *= 2;
index = (index+1)/2 -1;
//父亲
//左边树搜索完没找到那么就到右子树去搜索
if( index < 0 ){
return -1;
}
if( index & 1 ){
//父亲是左孩子,指向父亲的兄弟,即右孩子
++index;
break;
}
}
}
return -1;
}




static void _combine( struct buddy *self, int index )
{
for( ; ; ){
int buddy = index - 1 + (index & 1) * 2;
if( buddy < 0 || self->tree[buddy] != NODE_UNUSED ){
self->tree[index] = NODE_UNUSED;
while( ((index = (index + 1) / 2 - 1) >= 0) && self->tree[index] == NODE_FULL ){
self->tree[index] = NODE_SPLIT;
}
return;
}
index = (index + 1) / 2 - 1;
}
}

void buddy_free( struct buddy *self, int offset )
{
assert( offset < (1<< self->level));
int left = 0;
int length = 1 << self->level;
int index = 0;

for( ; ; ){
switch( self->tree[index] )
{
case NODE_USED:
assert(offset == left);
_combine(self, index);
return;
case NODE_UNUSED:
assert(0);
return;
default:
length /= 2;
if( offset < left+length ){
index = index * 2 + 1;
}else{
left += length;
index = index * 2 + 2;
}
break;
}
}
}

//计算buddy的大小
int buddy_size( struct buddy * self, int offset )
{
assert( offset < (1<< self->level) );
int left = 0;
int length = 1 << self->level;
int index = 0;

for( ; ; ){
switch( self->tree[index] )
{
case NODE_USED:
assert(offset == left);
return length;
//相当于break
case NODE_UNUSED:
assert(0);
return length;
default:
length /= 2;
if( offset < left+length ){
index = index * 2 + 1;
}else{
left += length;
index = index * 2 + 2;
}
break;
}
}
}

//具有递归调用
static void _dump(struct buddy * self, int index , int level)
{
switch( self->tree[index] )
{
case NODE_UNUSED:
//节点未使用
printf("(%d:%d)", _index_offset(index, level, self->level) , 1 << (self->level - level));
break;
case NODE_USED:
//节点已使用
printf("[%d:%d]", _index_offset(index, level, self->level) , 1 << (self->level - level));
break;
case NODE_FULL:
//节点已满
printf("{");
_dump(self, index * 2 + 1 , level+1);
//左孩子
_dump(self, index * 2 + 2 , level+1);
//右孩子
printf("}");
break;
default:
//节点裂开分叉生了一对双胞胎左右儿子
printf("(");
_dump(self, index * 2 + 1 , level+1);
//左孩子
_dump(self, index * 2 + 2 , level+1);
//右孩子
printf(")");
break;
}
}

void buddy_dump(struct buddy * self)
{
_dump(self, 0 , 0);
printf("\n");
}

static int test_alloc( struct buddy *b, int sz )
{

printf("\r\nstart alloc.\r\n");
int r = buddy_alloc(b, sz);
printf("alloc %d (sz= %d).\r\n\r\n",r,sz);
buddy_dump(b);
return r;
}

static void test_free( struct buddy *b, int addr )
{
printf( "free %d.\r\n", addr );
buddy_free( b, addr );
buddy_dump(b);
}

static void test_size(struct buddy *b, int addr)
{
int s = buddy_size(b,addr);
printf( "size addr = %d, (sz = %d).\r\n", addr, s );
}

//buddy 伙伴算法的简单实现
//只要看明白了这个c程序,就可以明白linux下的伙伴算法

void dump_array( unsigned char *p, int cnt )
{
int i = 0x00;
//printf( "p = %x.\r\n", p );
//printf( "cnt = %d.\r\n", cnt );
for( ; cnt; cnt-- ){
if( p[i] ){
printf( "p[%d] = 0x%x.\r\n", i, p[i] );
}
i++;
}
}

int main( void )
{
struct buddy * b;
int m1, m2, m3, m4, m5, m6;

b = buddy_new(3);
buddy_dump(b);


//dump_array( &b->tree[0], 32 );
m1 = test_alloc(b,2);
test_size(b,m1);
dump_array( &b->tree[0], 16 );

m2 = test_alloc(b,1);
test_size(b,m2);
dump_array( &b->tree[0], 16 );

m3 = test_alloc(b,2);
test_size(b,m3);
dump_array( &b->tree[0], 16 );

m4 = test_alloc(b,1);
test_size(b,m4);
dump_array( &b->tree[0], 16 );

m5 = test_alloc(b,2);
test_size(b,m5);
dump_array( &b->tree[0], 16 );



#if 0
m2 = test_alloc(b,9);
test_size(b,m2);
m3 = test_alloc(b,3);
test_size(b,m3);
m4 = test_alloc(b,7);
test_free(b,m3);
test_free(b,m1);
test_free(b,m4);
test_free(b,m2);

m5 = test_alloc(b,32);
test_free(b,m5);

m6 = test_alloc(b,0);
test_free(b,m6);

buddy_delete(b);
#endif
return 0;
}
#endif

#if 0
## Buddy Memory Allocation

A simple buddy memory allocation library .

See test.c for detail use.

## Question ?

* Send me an email : http://www.codingnow.com/2000/gmail.gif
* My Blog : http://blog.codingnow.com
* http://blog.codingnow.com/2011/12/buddy_memory_allocation.html (in Chinese)

.Phony : all clean

all : test

test : test.c buddy.c
gcc -g -Wall -o $@ $^

clean :
rm -f test test.exe
#endif

一个程序明白buddy算法

标签：算法 buddy

原文地址：http://blog.csdn.net/dp__mcu/article/details/43340159

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行