-Changed memory functions, Memory::alloc_static*, simplified them, made them aligned to 16

-Changed Vector<> template to fit this.

1 files changed, 181 insertions, 24 deletions

diff --git a/core/os/memory.cpp b/core/os/memory.cpp
index 4922a18335..cf42c3681a 100644
--- a/core/os/memory.cpp
+++ b/core/os/memory.cpp
@@ -30,9 +30,68 @@
 #include "error_macros.h"
 #include "copymem.h"
 #include <stdio.h>
+#include <stdlib.h>
+
+
+MID::MID(MemoryPoolDynamic::ID p_id) {
+
+	data = (Data*)memalloc(sizeof(Data));
+	data->refcount.init();
+	data->id=p_id;
+}
+
+void MID::unref() {
+
+	if (!data)
+		return;
+	if (data->refcount.unref()) {
+
+		if (data->id!=MemoryPoolDynamic::INVALID_ID)
+			MemoryPoolDynamic::get_singleton()->free(data->id);
+		memfree(data);
+	}
+
+	data=NULL;
+}
+Error MID::_resize(size_t p_size) {
+
+	if (p_size==0 && (!data || data->id==MemoryPoolDynamic::INVALID_ID))
+			return OK;
+	if (p_size && !data) {
+		// create data because we'll need it
+		data = (Data*)memalloc(sizeof(Data));
+		ERR_FAIL_COND_V( !data,ERR_OUT_OF_MEMORY );
+		data->refcount.init();
+		data->id=MemoryPoolDynamic::INVALID_ID;
+	}
+
+	if (p_size==0 && data && data->id==MemoryPoolDynamic::INVALID_ID) {
+
+		MemoryPoolDynamic::get_singleton()->free(data->id);
+		data->id=MemoryPoolDynamic::INVALID_ID;
+	}
+
+	if (p_size>0) {
+
+		if (data->id==MemoryPoolDynamic::INVALID_ID) {
+
+			data->id=MemoryPoolDynamic::get_singleton()->alloc(p_size,"Unnamed MID");
+			ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY );
+
+		} else {
+
+			MemoryPoolDynamic::get_singleton()->realloc(data->id,p_size);
+			ERR_FAIL_COND_V( data->id==MemoryPoolDynamic::INVALID_ID, ERR_OUT_OF_MEMORY );
+
+		}
+	}
+
+	return OK;
+}
+
 void * operator new(size_t p_size,const char *p_description) {
 
-	return Memory::alloc_static( p_size, p_description );
+	return Memory::alloc_static( p_size, false );
 }
 
 void * operator new(size_t p_size,void* (*p_allocfunc)(size_t p_size)) {
@@ -42,49 +101,147 @@ void * operator new(size_t p_size,void* (*p_allocfunc)(size_t p_size)) {
 
 #include <stdio.h>
 
-void * Memory::alloc_static(size_t p_bytes,const char *p_alloc_from) {
+#ifdef DEBUG_ENABLED
+size_t Memory::mem_usage=0;
+size_t Memory::max_usage=0;
+#endif
 
-	ERR_FAIL_COND_V( !MemoryPoolStatic::get_singleton(), NULL );
-	return MemoryPoolStatic::get_singleton()->alloc(p_bytes,p_alloc_from);
-}
-void * Memory::realloc_static(void *p_memory,size_t p_bytes) {
+size_t Memory::alloc_count=0;
 
-	ERR_FAIL_COND_V( !MemoryPoolStatic::get_singleton(), NULL );
-	return MemoryPoolStatic::get_singleton()->realloc(p_memory,p_bytes);
-}
 
-void Memory::free_static(void *p_ptr) {
+void * Memory::alloc_static(size_t p_bytes,bool p_pad_align) {
 
-	ERR_FAIL_COND( !MemoryPoolStatic::get_singleton());
-	MemoryPoolStatic::get_singleton()->free(p_ptr);
-}
 
+#ifdef DEBUG_ENABLED
+	bool prepad=true;
+#else
+	bool prepad=p_pad_align;
+#endif
+
+	void * mem = malloc( p_bytes + (prepad?PAD_ALIGN:0));
+
+	alloc_count++;
 
-size_t Memory::get_static_mem_available() {
+	ERR_FAIL_COND_V(!mem,NULL);
 
-	ERR_FAIL_COND_V( !MemoryPoolStatic::get_singleton(), 0);
-	return MemoryPoolStatic::get_singleton()->get_available_mem();
+	if (prepad) {
+		uint64_t *s = (uint64_t*)mem;
+		*s=p_bytes;
 
+		uint8_t *s8 = (uint8_t*)mem;
+
+#ifdef DEBUG_ENABLED
+		mem_usage+=p_bytes;
+		if (mem_usage>max_usage) {
+			max_usage=mem_usage;
+		}
+#endif
+		return s8 + PAD_ALIGN;
+	} else {
+		return mem;
+	}
 }
 
-size_t Memory::get_static_mem_max_usage() {
+void * Memory::realloc_static(void *p_memory,size_t p_bytes,bool p_pad_align) {
+
+	if (p_memory==NULL) {
+		return alloc_static(p_bytes,p_pad_align);
+	}
+
+	uint8_t *mem = (uint8_t*)p_memory;
+
+#ifdef DEBUG_ENABLED
+	bool prepad=true;
+#else
+	bool prepad=p_pad_align;
+#endif
+
+	if (prepad) {
+		mem-=PAD_ALIGN;
+		uint64_t *s = (uint64_t*)mem;
+
+#ifdef DEBUG_ENABLED
+		mem_usage-=*s;
+		mem_usage+=p_bytes;
+#endif
+
+		if (p_bytes==0) {
+			free(mem);
+			return NULL;
+		} else {
+			*s=p_bytes;
+
+			mem = (uint8_t*)realloc(mem,p_bytes+PAD_ALIGN);
+			ERR_FAIL_COND_V(!mem,NULL);
+
+			s = (uint64_t*)mem;
+
+			*s=p_bytes;
+
+			return mem+PAD_ALIGN;
+		}
+	} else {
+
+		mem = (uint8_t*)realloc(mem,p_bytes);
+
+		ERR_FAIL_COND_V(mem==NULL && p_bytes>0,NULL);
 
-	ERR_FAIL_COND_V( !MemoryPoolStatic::get_singleton(), 0);
-	return MemoryPoolStatic::get_singleton()->get_max_usage();
+		return mem;
+	}
 }
 
-size_t Memory::get_static_mem_usage() {
+void Memory::free_static(void *p_ptr,bool p_pad_align) {
 
-	ERR_FAIL_COND_V( !MemoryPoolStatic::get_singleton(), 0);
-	return MemoryPoolStatic::get_singleton()->get_total_usage();
+	ERR_FAIL_COND(p_ptr==NULL);
+
+	uint8_t *mem = (uint8_t*)p_ptr;
+
+#ifdef DEBUG_ENABLED
+	bool prepad=true;
+#else
+	bool prepad=p_pad_align;
+#endif
+
+	alloc_count--;
+
+	if (prepad) {
+		mem-=PAD_ALIGN;
+		uint64_t *s = (uint64_t*)mem;
+
+#ifdef DEBUG_ENABLED
+		mem_usage-=*s;
+#endif
+
+		free(mem);
+	} else {
+
+		free(mem);
+	}
 
 }
 
-void Memory::dump_static_mem_to_file(const char* p_file) {
+size_t Memory::get_mem_available() {
+
+	return 0xFFFFFFFFFFFFF;
+
+}
 
-	MemoryPoolStatic::get_singleton()->dump_mem_to_file(p_file);
+size_t Memory::get_mem_usage(){
+#ifdef DEBUG_ENABLED
+	return mem_usage;
+#else
+	return 0;
+#endif
+}
+size_t Memory::get_mem_max_usage(){
+#ifdef DEBUG_ENABLED
+	return max_usage;
+#else
+	return 0;
+#endif
 }
 
+
 MID Memory::alloc_dynamic(size_t p_bytes, const char *p_descr) {
 
 	MemoryPoolDynamic::ID id = MemoryPoolDynamic::get_singleton()->alloc(p_bytes,p_descr);