initial commit, 4.5 stable

core/os/memory.cpp

@@ -0,0 +1,233 @@
+/**************************************************************************/
+/*  memory.cpp                                                            */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "memory.h"
+
+#include "core/templates/safe_refcount.h"
+
+#include <cstdlib>
+
+void *operator new(size_t p_size, const char *p_description) {
+	return Memory::alloc_static(p_size, false);
+}
+
+void *operator new(size_t p_size, void *(*p_allocfunc)(size_t p_size)) {
+	return p_allocfunc(p_size);
+}
+
+#ifdef _MSC_VER
+void operator delete(void *p_mem, const char *p_description) {
+	CRASH_NOW_MSG("Call to placement delete should not happen.");
+}
+
+void operator delete(void *p_mem, void *(*p_allocfunc)(size_t p_size)) {
+	CRASH_NOW_MSG("Call to placement delete should not happen.");
+}
+
+void operator delete(void *p_mem, void *p_pointer, size_t check, const char *p_description) {
+	CRASH_NOW_MSG("Call to placement delete should not happen.");
+}
+#endif
+
+#ifdef DEBUG_ENABLED
+SafeNumeric<uint64_t> Memory::mem_usage;
+SafeNumeric<uint64_t> Memory::max_usage;
+#endif
+
+void *Memory::alloc_aligned_static(size_t p_bytes, size_t p_alignment) {
+	DEV_ASSERT(is_power_of_2(p_alignment));
+
+	void *p1, *p2;
+	if ((p1 = (void *)malloc(p_bytes + p_alignment - 1 + sizeof(uint32_t))) == nullptr) {
+		return nullptr;
+	}
+
+	p2 = (void *)(((uintptr_t)p1 + sizeof(uint32_t) + p_alignment - 1) & ~((p_alignment)-1));
+	*((uint32_t *)p2 - 1) = (uint32_t)((uintptr_t)p2 - (uintptr_t)p1);
+	return p2;
+}
+
+void *Memory::realloc_aligned_static(void *p_memory, size_t p_bytes, size_t p_prev_bytes, size_t p_alignment) {
+	if (p_memory == nullptr) {
+		return alloc_aligned_static(p_bytes, p_alignment);
+	}
+
+	void *ret = alloc_aligned_static(p_bytes, p_alignment);
+	if (ret) {
+		memcpy(ret, p_memory, p_prev_bytes);
+	}
+	free_aligned_static(p_memory);
+	return ret;
+}
+
+void Memory::free_aligned_static(void *p_memory) {
+	uint32_t offset = *((uint32_t *)p_memory - 1);
+	void *p = (void *)((uint8_t *)p_memory - offset);
+	free(p);
+}
+
+template <bool p_ensure_zero>
+void *Memory::alloc_static(size_t p_bytes, bool p_pad_align) {
+#ifdef DEBUG_ENABLED
+	bool prepad = true;
+#else
+	bool prepad = p_pad_align;
+#endif
+
+	void *mem;
+	if constexpr (p_ensure_zero) {
+		mem = calloc(1, p_bytes + (prepad ? DATA_OFFSET : 0));
+	} else {
+		mem = malloc(p_bytes + (prepad ? DATA_OFFSET : 0));
+	}
+
+	ERR_FAIL_NULL_V(mem, nullptr);
+
+	if (prepad) {
+		uint8_t *s8 = (uint8_t *)mem;
+
+		uint64_t *s = (uint64_t *)(s8 + SIZE_OFFSET);
+		*s = p_bytes;
+
+#ifdef DEBUG_ENABLED
+		uint64_t new_mem_usage = mem_usage.add(p_bytes);
+		max_usage.exchange_if_greater(new_mem_usage);
+#endif
+		return s8 + DATA_OFFSET;
+	} else {
+		return mem;
+	}
+}
+
+template void *Memory::alloc_static<true>(size_t p_bytes, bool p_pad_align);
+template void *Memory::alloc_static<false>(size_t p_bytes, bool p_pad_align);
+
+void *Memory::realloc_static(void *p_memory, size_t p_bytes, bool p_pad_align) {
+	if (p_memory == nullptr) {
+		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 -= DATA_OFFSET;
+		uint64_t *s = (uint64_t *)(mem + SIZE_OFFSET);
+
+#ifdef DEBUG_ENABLED
+		if (p_bytes > *s) {
+			uint64_t new_mem_usage = mem_usage.add(p_bytes - *s);
+			max_usage.exchange_if_greater(new_mem_usage);
+		} else {
+			mem_usage.sub(*s - p_bytes);
+		}
+#endif
+
+		if (p_bytes == 0) {
+			free(mem);
+			return nullptr;
+		} else {
+			*s = p_bytes;
+
+			mem = (uint8_t *)realloc(mem, p_bytes + DATA_OFFSET);
+			ERR_FAIL_NULL_V(mem, nullptr);
+
+			s = (uint64_t *)(mem + SIZE_OFFSET);
+
+			*s = p_bytes;
+
+			return mem + DATA_OFFSET;
+		}
+	} else {
+		mem = (uint8_t *)realloc(mem, p_bytes);
+
+		ERR_FAIL_COND_V(mem == nullptr && p_bytes > 0, nullptr);
+
+		return mem;
+	}
+}
+
+void Memory::free_static(void *p_ptr, bool p_pad_align) {
+	ERR_FAIL_NULL(p_ptr);
+
+	uint8_t *mem = (uint8_t *)p_ptr;
+
+#ifdef DEBUG_ENABLED
+	bool prepad = true;
+#else
+	bool prepad = p_pad_align;
+#endif
+
+	if (prepad) {
+		mem -= DATA_OFFSET;
+
+#ifdef DEBUG_ENABLED
+		uint64_t *s = (uint64_t *)(mem + SIZE_OFFSET);
+		mem_usage.sub(*s);
+#endif
+
+		free(mem);
+	} else {
+		free(mem);
+	}
+}
+
+uint64_t Memory::get_mem_available() {
+	return -1; // 0xFFFF...
+}
+
+uint64_t Memory::get_mem_usage() {
+#ifdef DEBUG_ENABLED
+	return mem_usage.get();
+#else
+	return 0;
+#endif
+}
+
+uint64_t Memory::get_mem_max_usage() {
+#ifdef DEBUG_ENABLED
+	return max_usage.get();
+#else
+	return 0;
+#endif
+}
+
+_GlobalNil::_GlobalNil() {
+	left = this;
+	right = this;
+	parent = this;
+}
+
+_GlobalNil _GlobalNilClass::_nil;