mem.c

在了解实时嵌入式操作系统内存管理机制的特点以及实时处理对内存管理需求的基础上

#include <vxWorks.h>
#include <tasklib.h>
#include <syslib.h>
#include <tylib.h>
#include <fiolib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define COUNT16		256
#define COUNT256		16

struct block16
{
	char block[16];
};

struct block256
{
	char block[256];
};

struct block16 *mem16;
struct block256 *mem256;
SEM_ID sem16, sem256;
bool free16[COUNT16], free256[COUNT256];

void mem_init()
{
	memset(free16, true, sizeof(free16));
	memset(free256, true, sizeof(free256));

	mem16 = (struct block16 *)malloc(COUNT16 * sizeof(struct block16));
	mem256 = (struct block256 *)malloc(COUNT256 * sizeof(struct block256));

	sem16 = semMCreate(SEM_Q_FIFO);
	sem256 = semMCreate(SEM_Q_FIFO);
}

void mem_exit()
{
	free(mem16);
	free(mem256);

	semDelete(sem16);
	semDelete(sem256);
}

/*
 * Find a free node from mem16[].
 * If no such node return -1, else return i.
 */
int mem_alloc16()
{
	int i, ret = -1;
	semTake(sem16, WAIT_FOREVER);
	for (i=0; i<COUNT16; i++)
	{
		if (free16[i])
		{
			free16[i] = false;
			ret = i;
			break;
		}
	}
	semGive(sem16);
	return ret;
}

/*
 * Find a free node from mem256[].
 * If no such node return -1, else return i.
 */
int mem_alloc256()
{
	int i, ret = -1;
	semTake(sem256, WAIT_FOREVER);
	for (i=0; i<COUNT256; i++)
	{
		if (free256[i])
		{
			free256[i] = false;
			ret = i;
			break;
		}
	}
	semGive(sem256);
	return ret;
}

/*
 * Allocate a piece of memory.
 * If size is to huge or blocks are busy return 0,
 * else return the normal pointer to allocated memory.
 */
void *mem_alloc(size_t size)
{
	int ret;
	if (size<=16 && (ret=mem_alloc16())!=-1)
		return &mem16[ret];
	else if (size<=256 && (ret=mem_alloc256())!=-1)
		return &mem256[ret];
	return 0;
}

/*
 * Free the memory allocated by mem_alloc().
 * If p is not a correct value, return p,
 * else let p = 0, then return 0.
 */
void *mem_free(void *p)
{
	if (p>=mem16 && p<(mem16+COUNT16 * sizeof(struct block16)))
	{
		if (((int)p-(int)mem16)%16 == 0)
		{
			semTake(sem16, WAIT_FOREVER);
			free16[((int)p-(int)mem16)/16] = true;
			semGive(sem16);
			p = 0;
		}
	}
	else if (p>=mem256 && p<(mem256+COUNT256 * sizeof(struct block256)))
	{
		if (((int)p-(int)mem256)%256 == 0)
		{
			semTake(sem256, WAIT_FOREVER);
			free256[((int)p-(int)mem256)/256] = true;
			semGive(sem256);
			p = 0;
		}
	}
	return p;
}

int task()
{
	char *p[8];
	int i, size[8] = {23, 65, 12, 8 ,36, 56, 950, 2};
	for (i=0; i<8; i++)
	{
		p[i] = (char *)mem_alloc(size[i]);
		printf("%08x = mem_alloc(%d)\n", p[i], size[i]);
	}

	taskDelay(sysClkRateGet()/10);

	for (i=0; i<8; i++)
	{
		mem_free(p[i]);
		printf("mem_free(%08x)\n", p[i]);
	}

	return 0;
}

int tid[16];

int main()
{
	mem_init();
	for (int i=0; i<16; i++)
		tid[i] = taskSpawn("memTask", 200, 0, 1024, (FUNCPTR)task, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);

	return 0;
}

void bye()
{
	for (int i=0; i<16; i++)
		taskDelete(tid[i]);
	mem_exit();
}