jack/42-archive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

norme ok, still need to fix without ft_

Browse source
This commit is contained in:
Jack Halford 2017-10-07 17:10:59 +02:00
parent a24acfd0a1
commit ac5300023b
21 changed files with 407 additions and 170 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
malloc/Makefile
View file

@ -6,7 +6,7 @@
# By: wescande <wescande@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2016/08/29 21:32:58 by wescande #+# #+# #
# Updated: 2017/03/31 18:08:35 by jhalford ### ########.fr #
# Updated: 2017/10/07 13:15:40 by jhalford ### ########.fr #
# #
# **************************************************************************** #
@ -25,12 +25,6 @@ OBJ_FLAGS =
LEN_NAME = `printf "%s" $(NAME) |wc -c`
DELTA = $$(echo "$$(tput cols)-31-$(LEN_NAME)"|bc)
LIBFT_DIR = libft/
LIBFT_LIB = $(LIBFT_DIR)libft.a
LIBFT_INC = $(LIBFT_DIR)includes/
LIBS =
SRC_DIR = srcs/
INC_DIR = includes/
OBJ_DIR = objs/
@ -38,7 +32,11 @@ OBJ_DIR = objs/
SRC_BASE = \
error_lib.c\
free.c\
ft_putchar.c\
ft_putnbr.c\
ft_putstr.c\
get_zone.c\
hexdump.c\
malloc.c\
node_lib.c\
realloc.c\
@ -52,15 +50,13 @@ INDEX = 0
SHELL := /bin/bash
all :
@make -C $(LIBFT_DIR)
@make -j $(NAME)
@make $(NAME_BIS)
$(NAME): $(LIBFT_LIB) $(OBJ_DIR) $(OBJS)
$(NAME): $(OBJ_DIR) $(OBJS)
@$(CC) $(OBJS) -o $(NAME) \
-I $(INC_DIR) \
-I $(LIBFT_INC) \
$(LIBS) $(LIBFT_LIB) $(MAIN_FLAGS) $(FLAGS)
$(LIBS) $(MAIN_FLAGS) $(FLAGS)
@printf "\r\033[38;5;117m✓ MAKE $(NAME)\033[0m\033[K\n"
$(NAME_BIS): $(NAME)
@ -71,9 +67,6 @@ $(NAME_BIS): $(NAME)
@ln -s $(NAME) $(NAME_BIS)
@printf "\r\033[38;5;117m✓ LINK $(NAME_BIS)\033[0m\033[K\n"
$(LIBFT_LIB):
@make -C $(LIBFT_DIR)
$(OBJ_DIR) :
@mkdir -p $(OBJ_DIR)
@mkdir -p $(dir $(OBJS))
@ -85,8 +78,7 @@ $(OBJ_DIR)%.o : $(SRC_DIR)%.c | $(OBJ_DIR)
@$(eval COLOR=$(shell list=(160 196 202 208 215 221 226 227 190 154 118 82 46); index=$$(($(PERCENT) * $${#list[@]} / 100)); echo "$${list[$$index]}"))
@printf "\r\033[38;5;%dm⌛ [%s]: %2d%% `printf '█%.0s' {0..$(DONE)}`%*s❙%*.*s\033[0m\033[K" $(COLOR) $(NAME) $(PERCENT) $(TO_DO) "" $(DELTA) $(DELTA) "$(shell echo "$@" | sed 's/^.*\///')"
@$(CC) $(FLAGS) $(OBJ_FLAG) -MMD -c $< -o $@\
-I $(INC_DIR)\
-I $(LIBFT_INC)
-I $(INC_DIR)
@$(eval INDEX=$(shell echo $$(($(INDEX)+1))))
clean: cleanlib
@ -96,9 +88,6 @@ clean: cleanlib
printf "\r\033[38;5;202m✗ clean $(NAME).\033[0m\033[K\n"; \
fi;
cleanlib:
@make -C $(LIBFT_DIR) clean
fclean: clean fcleanlib
@if [ -e $(NAME) ]; \
then \
@ -112,13 +101,8 @@ fclean: clean fcleanlib
fi;
@$(foreach n, $(shell echo libft_malloc_*.so), if [ -f $n ]; then rm -rf $n; printf "\r\033[38;5;196m✗ delete old lib $n.\033[0m\033[K\n"; fi;)
fcleanlib: cleanlib
@make -C $(LIBFT_DIR) fclean
re: fclean all
relib: fcleanlib $(LIBFT_LIB)
.PHONY : fclean clean re relib cleanlib fcleanlib
-include $(OBJS:.o=.d)

18
malloc/includes/malloc.h
View file

@ -6,24 +6,26 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 23:00:06 by jhalford #+# #+# */
/* Updated: 2017/03/06 17:43:23 by jhalford ### ########.fr */
/* Updated: 2017/10/07 16:25:06 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MALLOC_H
# define MALLOC_H
#ifndef FT_MALLOC_H
# define FT_MALLOC_H
#include "stdlib.h"
# pragma GCC visibility push(default)
void *calloc(size_t count, size_t size);
void free(void *ptr);
void *malloc(size_t size);
/* void *realloc(void *ptr, size_t size); */
void ft_free(void *ptr);
void *ft_malloc(size_t size);
void *ft_realloc(void *ptr, size_t size);
void show_alloc_mem(void);
void dump_alloc_mem(void);
/* void *calloc(size_t count, size_t size); */
/* void *reallocf(void *ptr, size_t size); */
/* void *valloc(size_t size); */
void show_alloc_mem(void);
# pragma GCC visibility pop

90
malloc/includes/malloc_internal.h
View file

@ -6,37 +6,78 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 23:00:24 by jhalford #+# #+# */
/* Updated: 2017/03/01 12:03:35 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:08:37 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MALLOC_INTERNAL_H
# define MALLOC_INTERNAL_H
# define M_NTINY (64)
# define M_NSMALL (1024)
# define M_PAGEALIGN(x) ((x / getpagesize() + 1) * getpagesize())
# define M_NTINY ((size_t)64)
# define M_NSMALL ((size_t)1024)
# define M_PAGEALIGN(x) ((x / getpagesize() + 1) * getpagesize()) * 10
# define M_TINYCHUNK (M_PAGEALIGN(101 * M_NTINY))
# define M_SMALLCHUNK (M_PAGEALIGN(101 * M_NSMALL))
# define M_MAGIC 1234567
# define M_CHUNKHEAD (sizeof(t_chunk) - alignof(t_chunk))
# define M_NODEHEAD (sizeof(t_node) - alignof(t_node))
# define M_CHUNKHEAD (sizeof(t_chunk))
# define M_NODEHEAD (sizeof(t_node))
# define M_ISTINY(x) (x < (M_NTINY + 1))
# define M_ISSMALL(x) (!M_TINY(x) && !M_LARGE(x))
# define M_ISLARGE(x) (M_SMALL < x)
# define M_ISSMALL(x) (!M_ISTINY(x) && !M_ISLARGE(x))
# define M_ISLARGE(x) (M_NSMALL < x)
# define NEXT(node) (node->islast ? NULL : (void*)node + node->size)
# define FT_ABS(x) (((x) < 0) ? -(x) : x)
/*
* DEBUG without malloc
*/
# define DP_N(n) ft_putnbr_fd(n, 2)
# define DP_H(n) ft_putnbr_hex_fd(n, 2)
# define DP_C(n) ft_putchar_fd(n, 2)
# define DP_S(n) ft_putstr_fd(n, 2)
# define DGPID DP_S("===");DP_N(getpid());DP_S("===");
# define DGW(d) DGPID;d;DP_C('\n')
# define DGS(s) do { DGW(DP_S(" "s)); } while(0)
# define DGSN(s, n) do { DGW(DP_S(" "s"=");DP_N(n)); } while(0)
# define DGSH(s, n) do { DGW(DP_S(" "s"=");DP_H(n)); } while(0)
# define FG_DEFAULT "\e[0m"
# define ON_BOLD "\e[1m"
# define ON_UNDERLINED "\e[4m"
# define ON_INVERTED "\e[7m"
# define FG_BLACK "\e[30m"
# define FG_RED "\e[31m"
# define FG_GREEN "\e[32m"
# define FG_YELLOW "\e[33m"
# define FG_BLUE "\e[34m"
# define FG_MAGENTA "\e[35m"
# define FG_CYAN "\e[36m"
# define BG_BLACK "\e[40m"
# define BG_RED "\e[41m"
# define BG_GREEN "\e[42m"
# define BG_YELLOW "\e[43m"
# define BG_BLUE "\e[44m"
# define BG_MAGENTA "\e[45m"
# define BG_CYAN "\e[46m"
# define BG_DEFAULT "\e[49m"
# define FBG_DEFAULT FG_DEFAULT BG_DEFAULT
#include "libft.h"
#include <sys/mman.h>
#include <stdalign.h>
#include <unistd.h>
typedef struct s_chunk {
struct s_chunk *next;
} t_chunk;
typedef struct s_node {
struct s_node *next;
size_t size;
int isfree:1;
unsigned int isfree:1;
unsigned int islast:1;
} t_node;
enum e_zones {
@ -47,17 +88,38 @@ enum e_zones {
};
extern t_chunk *g_zones[M_ZONES_MAX];
extern volatile int g_malloc_debug;
/*
* malloc_debug levels:
* 1: show chunks after malloc() and free()
* 2: show chunks before malloc() and free(), notify when coalescing.
* 3: show mmap() returns
*/
#include "malloc.h"
t_chunk *get_zone(size_t size);
int ret_free(void *ptr);
t_chunk **get_zone(size_t size);
t_node *find_node_firstfit(t_chunk *chunk, size_t size);
t_node *find_prev_node(t_chunk *zone, t_node *node);
int split_node(t_node *node, size_t size);
void show_free_mem(void);
void *hexdump(void *addr, unsigned int offset, unsigned int size);
void print_node(char fg[7], t_node *node);
void error_mmap(void);
void error_free_notalloc(void *ptr);
int ft_putchar(char c);
int ft_putchar_fd(char c, int fd);
int ft_putendl(char const *s);
int ft_putendl_fd(char const *s, int fd);
int ft_putstr(char const *s);
int ft_putstr_fd(char const *s, int fd);
int ft_putnbr(long n);
int ft_putnbr_fd(long n, int fd);
int ft_putnbr_hex(long n);
int ft_putnbr_hex_fd(long n, int fd);
#endif

1
malloc/libft

@ -1 +0,0 @@
Subproject commit 8c0961c50468d42c3527c208d7f4ae3c98646882

5
malloc/run.sh
View file

@ -1,7 +1,2 @@
#!/bin/bash
if [[ `uname` == 'Darwin' ]]; then
DYLD_LIBRARY_PATH=. DYLD_INSERT_LIBRARIES="libft_malloc.so" DYLD_FORCE_FLAT_NAMESPACE=1 $@
else
echo $PWD
LD_LIBRARY_PATH=$PWD/. $@
fi

4
malloc/srcs/error_lib.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/18 19:34:23 by jhalford #+# #+# */
/* Updated: 2017/02/18 20:08:32 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:06:51 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
@ -24,7 +24,6 @@ void error_free_notalloc(void *ptr)
ft_putstr_fd(" malloc: error for object ", fd);
ft_putnbr_hex_fd((long)ptr, fd);
ft_putendl_fd(": pointer being freed was not allocated"FG_DEFAULT, fd);
/* exit(134); */
}
void error_mmap(void)
@ -37,5 +36,4 @@ void error_mmap(void)
ft_putstr_fd(", ??? ", fd);
ft_putstr_fd(")", fd);
ft_putendl_fd(" malloc: mmap failed", fd);
/* exit(134); */
}

50
malloc/srcs/free.c
View file

@ -6,48 +6,62 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 12:28:03 by jhalford #+# #+# */
/* Updated: 2017/03/01 12:04:36 by jhalford ### ########.fr */
/* Updated: 2017/10/07 16:29:44 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
volatile int g_malloc_debug;
int coalesce_nodes(t_node *node)
{
t_node *next;
if ((next = node->next) && next->isfree)
show_alloc_mem();
if (node->islast)
return (0);
next = (void*)node + node->size;
if (node->isfree && next->isfree)
{
if (g_malloc_debug >= 2)
{
DGSH("coalescing 2 nodes at addr", (long)node);
DGSH("and addr", (long)next);
}
node->islast = next->islast;
node->size += next->size;
node->next = next->next;
}
return (0);
}
void free(void *ptr)
int ret_free(void *ptr)
{
t_chunk *zone;
t_node *node;
t_node *prev;
/* DGSH("free i", (int)ptr); */
/* DGSH("free ui", (unsigned int)ptr); */
/* DGSH("free ll", (long long)ptr); */
DGSH("free ull", (unsigned long long)ptr);
if (!ptr)
return ;
return (2);
node = ptr - M_NODEHEAD;
DGSN("node->size", node->size);
zone = get_zone(node->size);
DGSH("free", (long)ptr);
zone = *get_zone(node->size);
if (!(prev = find_prev_node(zone, node)))
{
error_free_notalloc(ptr);
return ;
return (1);
}
DGSH("free", (long)ptr);
coalesce_nodes(node);
DGSH("free", (long)ptr);
node->isfree = 1;
coalesce_nodes(prev);
DGS("successful free");
return (0);
}
void ft_free(void *ptr)
{
if (g_malloc_debug >= 1)
DGSH("free called with addr", (long)ptr);
if (g_malloc_debug >= 2)
show_alloc_mem();
if (ret_free(ptr) == 1)
error_free_notalloc(ptr);
if (g_malloc_debug >= 1)
show_alloc_mem();
}

25
malloc/srcs/get_zone.c → malloc/srcs/ft_putchar.c
View file

@ -1,28 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_zones.c :+: :+: :+: */
/* ft_putchar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/18 17:53:41 by jhalford #+# #+# */
/* Updated: 2017/02/18 20:06:53 by jhalford ### ########.fr */
/* Created: 2017/10/07 17:07:04 by jhalford #+# #+# */
/* Updated: 2017/10/07 17:07:06 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
t_chunk *g_zones[M_ZONES_MAX] =
int ft_putchar_fd(char c, int fd)
{
NULL,
NULL,
NULL,
};
t_chunk *get_zone(size_t size)
{
if (M_ISLARGE(size))
return (g_zones[M_LARGE]);
else
return (g_zones[M_ISTINY(size) ? M_TINY : M_SMALL]);
return (write(fd, &c, 1));
}
int ft_putchar(char c)
{
return (write(1, &c, 1));
}

44
malloc/srcs/ft_putnbr.c Normal file
View file

@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/10/07 17:07:00 by jhalford #+# #+# */
/* Updated: 2017/10/07 17:08:25 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
int ft_putnbr_loop(long n, int base, int fd)
{
if (n >= base)
ft_putnbr_loop(n / base, base, fd);
return (ft_putchar_fd("0123456789abcdef"[n % base], fd));
}
int ft_putnbr_hex_fd(long n, int fd)
{
ft_putstr_fd("0x", fd);
return (ft_putnbr_loop(n, 16, fd));
}
int ft_putnbr_fd(long n, int fd)
{
if (n < 0)
ft_putchar_fd('-', fd);
n = FT_ABS(n);
return (ft_putnbr_loop(n, 10, fd));
}
int ft_putnbr_hex(long n)
{
return (ft_putnbr_hex_fd(n, 1));
}
int ft_putnbr(long n)
{
return (ft_putnbr_fd(n, 1));
}

49
malloc/srcs/ft_putstr.c Normal file
View file

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/10/07 17:07:41 by jhalford #+# #+# */
/* Updated: 2017/10/07 17:08:06 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
if (!s)
return (0);
while (s[i])
i++;
return (i);
}
int ft_putendl_fd(char const *s, int fd)
{
char nl;
nl = '\n';
write(fd, s, ft_strlen(s));
return (write(fd, &nl, 1));
}
int ft_putendl(char const *s)
{
return (ft_putendl_fd(s, 1));
}
int ft_putstr_fd(char const *s, int fd)
{
return (write(fd, s, ft_strlen(s)));
}
int ft_putstr(char const *s)
{
return (write(1, s, ft_strlen(s)));
}

53
malloc/srcs/hexdump.c Normal file
View file

@ -0,0 +1,53 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* hexdump.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/10/07 15:44:13 by jhalford #+# #+# */
/* Updated: 2017/10/07 17:09:29 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
int ft_dumpnbr_hex(char n)
{
if (n < 0xa)
ft_putchar('0');
return (ft_putnbr_loop(n, 16, 1));
}
static void print_hex_contents(void *addr, unsigned int size)
{
void *a;
a = addr;
while (a - addr < 16)
{
if ((a - addr) >= size)
break ;
else
ft_dumpnbr_hex(*(unsigned char*)a);
ft_putchar(' ');
a++;
}
}
void *hexdump(void *addr, unsigned int offset, unsigned int size)
{
void *a;
addr += offset;
a = addr;
if (addr == NULL)
return (addr);
while ((a - addr) < size)
{
print_hex_contents(a, (size - (a - addr)));
ft_putchar('\n');
a += 16;
}
return (addr);
}

50
malloc/srcs/malloc.c
View file

@ -6,12 +6,31 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 12:28:02 by jhalford #+# #+# */
/* Updated: 2017/03/01 12:15:24 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:10:38 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
t_chunk *g_zones[M_ZONES_MAX] =
{
NULL,
NULL,
NULL,
};
volatile int g_malloc_debug = 0;
t_chunk **get_zone(size_t size)
{
if (M_ISLARGE(size))
return (&g_zones[M_LARGE]);
else if (M_ISSMALL(size))
return (&g_zones[M_SMALL]);
else
return (&g_zones[M_TINY]);
}
void add_chunk(t_chunk **chunk, size_t size)
{
int chunk_size;
@ -22,31 +41,44 @@ void add_chunk(t_chunk **chunk, size_t size)
chunk_size = M_PAGEALIGN(size);
else
chunk_size = M_ISTINY(size) ? M_TINYCHUNK : M_SMALLCHUNK;
chunk_size += M_CHUNKHEAD;
if (!(new = mmap(NULL, chunk_size, PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE, -1, 0)))
error_mmap();
if (g_malloc_debug >= 3)
DGSN("malloc_debug", g_malloc_debug);
new->next = *chunk;
*chunk = new;
node = (t_node*)(*chunk + 1);
node->size = chunk_size - M_CHUNKHEAD;
node->next = 0;
node->isfree = 1;
node->islast = 1;
}
void *malloc(size_t size)
void *ft_malloc(size_t size)
{
t_chunk *zone;
t_chunk **zone;
t_node *node;
void *ret;
g_malloc_debug = 1;
if (g_malloc_debug >= 1)
DGSN("malloc called with size", size);
if (g_malloc_debug >= 2)
{
DGSN("malloc", size);
show_alloc_mem();
}
size += M_NODEHEAD;
zone = get_zone(size);
DGSH("zone", (long)zone);
while (!(node = find_node_firstfit(zone, size)))
add_chunk(&zone, size);
while (!(node = find_node_firstfit(*zone, size)))
add_chunk(zone, size);
split_node(node, size);
ret = (void*)node + M_NODEHEAD;
DGSH("to user", (long)ret);
ret = (void*)(node + 1);
if (g_malloc_debug >= 1)
{
DGSH("user got ptr", (long)ret);
show_alloc_mem();
}
return (ret);
}

24
malloc/srcs/node_lib.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 12:28:15 by jhalford #+# #+# */
/* Updated: 2017/03/01 12:04:08 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:09:11 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,9 +19,11 @@ t_node *find_node_firstfit(t_chunk *chunk, size_t size)
if (!chunk)
return (NULL);
node = (t_node*)(chunk + 1);
while (node && !(node->isfree && node->size >= size))
while (node)
{
node = node->next;
if (node->isfree && node->size >= size)
break ;
node = NEXT(node);
}
return (node);
}
@ -30,13 +32,15 @@ int split_node(t_node *node, size_t size)
{
t_node *new_node;
new_node = (void*)node + size;
new_node->next = node->next;
new_node->size = node->next - new_node;
new_node->isfree = 1;
node->next = new_node;
node->size -= new_node->size;
node->isfree = 0;
if (node->size - size <= M_NODEHEAD)
return (0);
new_node = (void*)node + size;
new_node->size = node->size - size;
new_node->isfree = 1;
new_node->islast = node->islast;
node->islast = 0;
node->size = size;
return (0);
}
@ -54,7 +58,7 @@ t_node *find_prev_node(t_chunk *zone, t_node *node)
if (n == node)
return (prev);
prev = n;
n = n->next;
n = NEXT(n);
}
zone = zone->next;
}

10
malloc/srcs/realloc.c
View file

@ -6,15 +6,15 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/18 13:23:20 by jhalford #+# #+# */
/* Updated: 2017/03/01 12:15:31 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:08:46 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
void *realloc(void *ptr, size_t size)
void *ft_realloc(void *ptr, size_t size)
{
ft_putendl("realloc called");
free(ptr);
return (malloc(size));
if (ret_free(ptr))
return (NULL);
return (ft_malloc(size));
}

67
malloc/srcs/show_alloc_mem.c
View file

@ -6,60 +6,65 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 12:28:20 by jhalford #+# #+# */
/* Updated: 2017/02/21 16:37:55 by jhalford ### ########.fr */
/* Updated: 2017/10/07 17:06:14 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "malloc_internal.h"
t_node *tiny_zone;
t_node *small_zone;
t_node *large_zone;
t_node *tiny_alloc;
t_node *small_alloc;
t_node *large_alloc;
t_chunk *g_zones[M_ZONES_MAX];
void print_node(char color[7], t_node *node)
{
ft_putstr("\t");
ft_putstr(color);
/* ft_putnbr_hex((long)node->data); */
ft_putnbr_hex((long)(node));
ft_putstr(" - ");
/* ft_putnbr_hex((long)node->data + node->size); */
ft_putnbr_hex((long)(node + 1));
ft_putstr(" - ");
ft_putnbr_hex((long)((void*)node + node->size));
ft_putstr(FBG_DEFAULT" : ");
ft_putnbr(node->size);
ft_putendl(" bytes");
ft_putstr(" bytes");
ft_putchar('\n');
}
void show_alloc_zone(char *name, t_node *alloc, t_node *zone, size_t (*total)[3])
void show_chunk(char *name, t_chunk *chunk, int dump)
{
if (alloc || zone)
t_node *node;
ft_putstr(name);
while (alloc)
if (!chunk)
{
print_node(FG_RED, alloc);
(*total)[1] += alloc->size;
alloc = alloc->next;
ft_putstr("empty");
ft_putchar('\n');
return ;
}
while (zone)
while (chunk)
{
print_node(FG_GREEN, zone);
(*total)[0] += zone->size;
zone = zone->next;
ft_putchar('\n');
node = (t_node*)(chunk + 1);
while (node)
{
print_node(node->isfree ? FG_GREEN : FG_RED, node);
if (dump && !node->isfree)
hexdump(node, M_NODEHEAD, node->size - M_NODEHEAD);
node = NEXT(node);
}
chunk = chunk->next;
}
}
void show_alloc_mem(void)
{
size_t total[3];
total[0] = 0;
total[1] = 0;
show_alloc_zone("TINY:", tiny_alloc, tiny_zone, &total);
show_alloc_zone("SMALL:", small_alloc, small_zone, &total);
show_alloc_zone("LARGE:", large_alloc, large_zone, &total);
printf("Total:");
printf("\t%7zu bytes free\n", total[0]);
printf("\t%7zu bytes allocated\n", total[1]);
printf("\t%7zu bytes mmap'd\n", total[0] + total[1]);
show_chunk("TINY: ", g_zones[M_TINY], 0);
show_chunk("SMALL: ", g_zones[M_SMALL], 0);
show_chunk("LARGE: ", g_zones[M_LARGE], 0);
}
void dump_alloc_mem(void)
{
show_chunk("TINY: ", g_zones[M_TINY], 1);
show_chunk("SMALL: ", g_zones[M_SMALL], 1);
show_chunk("LARGE: ", g_zones[M_LARGE], 1);
}

3
malloc/tests/test1.c
View file

@ -1,5 +1,6 @@
#include "../includes/malloc.h"
void *ft_malloc(size_t size);
int main(void)
{
int i;
@ -8,7 +9,7 @@ int main(void)
i = 0;
while (i < 1024)
{
addr = (char*)malloc(1024);
addr = (char*)ft_malloc(1024);
addr[0] = 42;
i++;
}

4
malloc/tests/test2.c
View file

@ -8,9 +8,9 @@ int main(void)
i = 0;
while (i < 1024)
{
addr = (char*)malloc(1024);
addr = (char*)ft_malloc(1024);
addr[0] = 42;
free(addr);
ft_free(addr);
i++;
}
return (0);

6
malloc/tests/test3.5.c
View file

@ -15,11 +15,11 @@ int main(void)
char *addr2;
char *addr3;
addr1 = (char*)malloc(16*M);
addr1 = (char*)ft_malloc(16*M);
strcpy(addr1, "Bonjours\n");
print(addr1);
addr2 = (char*)malloc(16*M);
addr3 = (char*)realloc(addr1, 128*M);
addr2 = (char*)ft_malloc(16*M);
addr3 = (char*)ft_realloc(addr1, 128*M);
addr3[127*M] = 42;
print(addr3);
return (0);

4
malloc/tests/test3.c
View file

@ -15,10 +15,10 @@ int main(void)
char *addr1;
char *addr3;
addr1 = (char*)malloc(16*M);
addr1 = (char*)ft_malloc(16*M);
strcpy(addr1, "Bonjours\n");
print(addr1);
addr3 = (char*)realloc(addr1, 128*M);
addr3 = (char*)ft_realloc(addr1, 128*M);
addr3[127*M] = 42;
print(addr3);
return (0);

8
malloc/tests/test4.c
View file

@ -11,10 +11,10 @@ int main(void)
{
char *addr;
addr = malloc(16);
free(NULL);
free((void*)addr + 5);
if (realloc((void*)addr + 5, 10) == NULL)
addr = ft_malloc(16);
ft_free(NULL);
ft_free((void*)addr + 5);
if (ft_realloc((void*)addr + 5, 10) == NULL)
print("Bonjours\n");
return (0);
}

10
malloc/tests/test5.c
View file

@ -2,11 +2,11 @@
int main(void)
{
malloc(1024);
malloc(1024 * 32);
malloc(1024 * 1024);
malloc(1024 * 1024 * 16);
malloc(1024 * 1024 * 128);
ft_malloc(1024);
ft_malloc(1024 * 32);
ft_malloc(1024 * 1024);
ft_malloc(1024 * 1024 * 16);
ft_malloc(1024 * 1024 * 128);
show_alloc_mem();
return (0);
}