fixed glib warnings about using g_mem_set_vtable() and revised memory limiting

 * we were basing the glib allocators on throwing std::bad_alloc just like
   the C++ operators. However, this always was unsafe since we were throwing
   exceptions across plain-C frames (Glib).
   Also, the memory vtable has been deprecated in Glib, resulting in
   ugly warnings.
 * Instead, we now let the C++ new/delete operators work like Glib
   by basing them on g_malloc/g_slice.
   This means they will assert and the application will terminate
   abnormally in case of OOM. OOMs cannot be handled properly anyway, so it is
   more important to have a good memory limiting mechanism.
 * Memory limiting has been completely revised.
   Instead of approximating undo stack sizes using virtual methods
   (which is unprecise and comes with a performance penalty),
   we now use a common base class SciTECO::Object to count the memory
   required by all objects allocated within SciTECO.
   This is less precise than using global replacement new/deletes
   which would allow us to control allocations in all C++ code including
   Scintilla, but they are only supported as of C++14 (GCC 5) and adding compile-time
   checks would be cumbersome.
   In any case, we're missing Glib allocations (esp. strings).
 * As a platform-specific extension, on Linux/glibc we use mallinfo()
   to count the exact memory usage of the process.
   On Windows, we use GetProcessMemoryInfo() -- the latter implementation
   is currently UNTESTED.
 * We use g_malloc() for new/delete operators when there is
   malloc_trim() since g_slice does not free heap chunks properly
   (probably does its own mmap()ing), rendering malloc_trim() ineffective.
   We've also benchmarked g_slice on Linux/glib (malloc_trim() shouldn't
   be available elsewhere) and found that it brings no significant
   performance benefit.
   On all other platforms, we use g_slice since it is assumed
   that it at least does not hurt.
   The new g_slice based allocators should be tested on MSVCRT
   since I assume that they bring a significant performance benefit
   on Windows.
 * Memory limiting does now work in batch mode as well and is still
   enabled by default.
 * The old UndoTokenWithSize CRTP hack could be removed.
   UndoStack operations should be a bit faster now.
   But on the other hand, there will be an overhead due to repeated
   memory limit checking on every processed character.

1 files changed, 6 insertions, 66 deletions

diff --git a/src/undo.h b/src/undo.h
index 1e92b16..7ca6c30 100644
--- a/src/undo.h
+++ b/src/undo.h
@@ -25,18 +25,15 @@
 #include <glib.h>
 #include <glib/gprintf.h>
 
+#include "memory.h"
+
 #ifdef DEBUG
 #include "parser.h"
 #endif
 
 namespace SciTECO {
 
-/**
- * Default undo stack memory limit (500mb).
- */
-#define UNDO_MEMORY_LIMIT_DEFAULT (500*1024*1024)
-
-class UndoToken {
+class UndoToken : public Object {
 public:
 	SLIST_ENTRY(UndoToken) tokens;
 
@@ -55,35 +52,10 @@ public:
 	virtual ~UndoToken() {}
 
 	virtual void run(void) = 0;
-
-	/**
-	 * Return approximated size of this object.
-	 * If possible it should take all heap objects
-	 * into account that are memory-managed by the undo
-	 * token.
-	 * For a simple implementation, you may derive
-	 * from UndoTokenWithSize.
-	 */
-	virtual gsize get_size(void) const = 0;
-};
-
-/**
- * UndoToken base class employing the CRTP idiom.
- * Deriving this class adds a size approximation based
- * on the shallow size of the template parameter.
- */
-template <class UndoTokenImpl>
-class UndoTokenWithSize : public UndoToken {
-public:
-	gsize
-	get_size(void) const
-	{
-		return sizeof(UndoTokenImpl);
-	}
 };
 
 template <typename Type>
-class UndoTokenVariable : public UndoTokenWithSize< UndoTokenVariable<Type> > {
+class UndoTokenVariable : public UndoToken {
 	Type *ptr;
 	Type value;
 
@@ -125,13 +97,6 @@ public:
 		*ptr = str;
 		str = NULL;
 	}
-
-	gsize
-	get_size(void) const
-	{
-		return str ? sizeof(*this) + strlen(str) + 1
-		           : sizeof(*this);
-	}
 };
 
 template <class Type>
@@ -155,47 +120,22 @@ public:
 		*ptr = obj;
 		obj = NULL;
 	}
-
-	gsize
-	get_size(void) const
-	{
-		return obj ? sizeof(*this) + sizeof(*obj)
-		           : sizeof(*this);
-	}
 };
 
-extern class UndoStack {
+extern class UndoStack : public Object {
 	SLIST_HEAD(Head, UndoToken) head;
 
-	/**
-	 * Current approx. memory usage of all
-	 * undo tokens in the stack.
-	 * It is only up to date if memory limiting
-	 * is enabled.
-	 */
-	gsize memory_usage;
-
 	void push(UndoToken *token);
 
 public:
 	bool enabled;
 
-	/**
-	 * Undo stack memory limit in bytes.
-	 * 0 means no limiting.
-	 */
-	gsize memory_limit;
-
-	UndoStack(bool _enabled = false)
-	         : memory_usage(0), enabled(_enabled),
-	           memory_limit(UNDO_MEMORY_LIMIT_DEFAULT)
+	UndoStack(bool _enabled = false) : enabled(_enabled)
 	{
 		SLIST_INIT(&head);
 	}
 	~UndoStack();
 
-	void set_memory_limit(gsize new_limit = 0);
-
 	/**
 	 * Allocate and push undo token.
 	 *