aboutsummaryrefslogblamecommitdiff
path: root/8.7/malloc.c
blob: 1b7b345b7ee4347b61d83d1cf8e6090ca8d7ea6e (plain) (tree) 
1e05635


























































































































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


























































































































                                                                             
#include <unistd.h>
#include <stdio.h>
#include "malloc.h"

#define NALLOC		128
#define MAX_BYTES	(size_t) 8192

typedef long long Align;

typedef union header {
	struct {
		union header *ptr;
		size_t size;
	} s;

	Align x;
} Header;

static size_t maxalloc;
static Header base;
static Header *freep = NULL;

static Header *my_morecore(size_t nunits);

void *my_calloc(size_t n ,size_t size)
{
	char *p, *temp;
	size_t nb;

	nb = n * size;
	if ((p = temp = my_malloc(nb)) == NULL)
		while (nb-- > 0)
			*temp++ = '\0';

	return p;
}

void *my_malloc(size_t nbytes)
{
	Header *prevp, *p;
	size_t nunits;

	if (nbytes > MAX_BYTES) {
		fprintf(stderr, "alloc:can't allocate more than %lu bytes\n",
		      MAX_BYTES);
		return NULL;
	}

	if ((prevp = freep) == NULL) {
		base.s.ptr = prevp = freep = &base;
		base.s.size = 0;
	}

	nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
	for (p = freep->s.ptr; ; prevp = p, p = p->s.ptr) {
		if (p->s.size >= nunits) {
			if (p->s.size == nunits) {
				prevp->s.ptr = p->s.ptr;
			} else {
				p->s.size -= nunits;
				p += p->s.size;
				p->s.size = nunits;
			}

			freep = prevp;
			return (void *)(p + 1);
		}

		if (p == freep)
			if ((p = my_morecore(nunits)) == NULL)
				return NULL;
	}

	return NULL;
}

static Header *my_morecore(size_t nunits)
{
	Header *p;

	if (nunits < NALLOC)
		nunits = NALLOC;

	if ((p = sbrk(nunits * sizeof(Header))) == (Header *) -1)
		return NULL;

	if ((p->s.size = nunits) > maxalloc)
		maxalloc = nunits;

	my_free (p + 1);
	return freep;
}

void my_free(void *ap)
{
	Header *bp, *p;

	bp = (Header *)ap - 1;
	if (bp->s.size == 0 || bp->s.size > maxalloc) {
		fprintf(stderr, "alloc: can't free %lu units", bp->s.size);
		return;
	}
	for (p = freep; !(bp > p && bp < p->s.ptr) ; p = p->s.ptr)
		if (p >= p->s.ptr && (bp > p || bp < p->s.ptr))
			break;

	if (bp + bp->s.size == p->s.ptr) {
		bp->s.size += p->s.ptr->s.size;
		bp->s.ptr = p->s.ptr->s.ptr;
	} else {
		bp->s.ptr = p->s.ptr;
	}

	if (p + p->s.size == bp) {
		p->s.size += bp->s.size;
		p->s.ptr = bp->s.ptr;
	} else {
		p->s.ptr = bp;
	}

	freep = p;
}