ALLOC_HAX: play games with memory allocation for speed boost.

3 files changed, 163 insertions, 6 deletions

diff --git a/generic/tkTreeCtrl.c b/generic/tkTreeCtrl.c
index ae75530..f9f1358 100644
--- a/generic/tkTreeCtrl.c
+++ b/generic/tkTreeCtrl.c
@@ -7,7 +7,7 @@
  * Copyright (c) 2002-2003 Christian Krone
  * Copyright (c) 2003-2004 ActiveState, a division of Sophos
  *
- * RCS: @(#) $Id: tkTreeCtrl.c,v 1.34 2005/05/13 19:44:02 treectrl Exp $
+ * RCS: @(#) $Id: tkTreeCtrl.c,v 1.35 2005/05/17 01:19:04 treectrl Exp $
  */
 
 #include "tkTreeCtrl.h"
@@ -136,12 +136,12 @@ static Tk_OptionSpec optionSpecs[] = {
      "0",
      Tk_Offset(TreeCtrl, itemPadXObj),
      Tk_Offset(TreeCtrl, itemPadX),
-     TK_CONFIG_NULL_OK, (ClientData) &PadAmountOption, 0},
-    {TK_OPTION_PIXELS, "-itempady", (char *) NULL, (char *) NULL,
+     0, (ClientData) &PadAmountOption, 0},
+    {TK_OPTION_CUSTOM, "-itempady", (char *) NULL, (char *) NULL,
      "0",
      Tk_Offset(TreeCtrl, itemPadYObj),
      Tk_Offset(TreeCtrl, itemPadY),
-     TK_CONFIG_NULL_OK, (ClientData) &PadAmountOption, 0},
+     0, (ClientData) &PadAmountOption, 0},
 #endif
     {TK_OPTION_STRING, "-itemprefix", "itemPrefix", "ItemPrefix",
      "", -1, Tk_Offset(TreeCtrl, itemPrefix), 0, (ClientData) NULL, 0},
@@ -323,6 +323,10 @@ static int TreeObjCmd(ClientData clientData, Tcl_Interp *interp,
     Tcl_InitHashTable(&tree->styleHash, TCL_STRING_KEYS);
     Tcl_InitHashTable(&tree->imageHash, TCL_STRING_KEYS);
 
+#ifdef ALLOC_HAX
+	tree->allocData = AllocHax_Init();
+#endif
+
     Tree_InitColumns(tree);
     TreeItem_Init(tree);
     TreeNotify_Init(tree);
@@ -1452,6 +1456,10 @@ static void TreeDestroy(char *memPtr)
 
     Tcl_DeleteHashTable(&tree->selection);
 
+#ifdef ALLOC_HAX
+    AllocHax_Finalize(tree->allocData);
+#endif
+
     WFREE(tree, TreeCtrl);
 }
 
diff --git a/generic/tkTreeCtrl.h b/generic/tkTreeCtrl.h
index f0f7a97..4646e9c 100644
--- a/generic/tkTreeCtrl.h
+++ b/generic/tkTreeCtrl.h
@@ -7,7 +7,7 @@
  * Copyright (c) 2002-2003 Christian Krone
  * Copyright (c) 2003 ActiveState Corporation
  *
- * RCS: @(#) $Id: tkTreeCtrl.h,v 1.25 2005/05/14 22:17:40 treectrl Exp $
+ * RCS: @(#) $Id: tkTreeCtrl.h,v 1.26 2005/05/17 01:19:05 treectrl Exp $
  */
 
 #include "tkPort.h"
@@ -42,6 +42,7 @@
 #endif
 
 #define SELECTION_VISIBLE
+#define ALLOC_HAX
 
 typedef struct TreeCtrl TreeCtrl;
 typedef struct TreeColumn_ *TreeColumn;
@@ -297,6 +298,9 @@ struct TreeCtrl
     Tk_OptionTable itemOptionTable;
     int itemPrefixLen;		/* -itemprefix */
     int columnPrefixLen;	/* -columnprefix */
+#ifdef ALLOC_HAX
+	ClientData allocData;
+#endif
 };
 
 #define TREE_CONF_FONT 0x0001
@@ -724,6 +728,15 @@ extern void PSTSave(PerStateInfo *pInfo, PerStateInfo *pSave);
 extern void PSTRestore(TreeCtrl *tree, PerStateType *typePtr,
     PerStateInfo *pInfo, PerStateInfo *pSave);
 
+#ifdef ALLOC_HAX
+extern ClientData AllocHax_Init(void);
+extern void AllocHax_Finalize(ClientData data);
+extern char *AllocHax_Alloc(ClientData data, int size);
+extern char *AllocHax_CAlloc(ClientData data, int size, int count, int roundUp);
+extern void AllocHax_Free(ClientData data, char *ptr, int size);
+extern void AllocHax_CFree(ClientData data, char *ptr, int size, int count, int roundUp);
+#endif
+
 /*****/
 
 #define STATIC_SIZE 20
diff --git a/generic/tkTreeUtils.c b/generic/tkTreeUtils.c
index f8f6707..9ada3e9 100644
--- a/generic/tkTreeUtils.c
+++ b/generic/tkTreeUtils.c
@@ -5,7 +5,7 @@
  *
  * Copyright (c) 2002-2005 Tim Baker
  *
- * RCS: @(#) $Id: tkTreeUtils.c,v 1.13 2005/05/10 22:38:45 treectrl Exp $
+ * RCS: @(#) $Id: tkTreeUtils.c,v 1.14 2005/05/17 01:21:14 treectrl Exp $
  */
 
 #include "tkTreeCtrl.h"
@@ -2049,3 +2049,139 @@ void PSTRestore(
     pInfo->count = pSave->count;
 }
 
+#ifdef ALLOC_HAX
+#define ALLOC_BLOCK_SIZE 128
+
+typedef struct AllocElem AllocElem;
+typedef struct AllocList AllocList;
+typedef struct AllocData AllocData;
+
+struct AllocElem
+{
+	AllocElem *next;
+	int free;
+	char d[1];
+};
+
+struct AllocList
+{
+	int size;
+	AllocElem *head;
+	AllocList *next;
+	AllocElem **blocks;
+	int blockCount;
+};
+
+struct AllocData
+{
+	AllocList *freeLists;
+};
+
+char *AllocHax_Alloc(ClientData data, int size)
+{
+	AllocList *freeLists = ((AllocData *) data)->freeLists;
+	AllocList *freeList = freeLists;
+	AllocElem *elem, *result;
+	int i;
+
+	while ((freeList != NULL) && (freeList->size != size))
+		freeList = freeList->next;
+
+	if (freeList == NULL) {
+		freeList = (AllocList *) ckalloc(sizeof(AllocList));
+		freeList->size = size;
+		freeList->head = NULL;
+		freeList->next = freeLists;
+		freeList->blocks = NULL;
+		freeList->blockCount = 0;
+		freeLists = freeList;
+		((AllocData *) data)->freeLists = freeLists;
+	}
+
+	if (freeList->head != NULL) {
+		elem = freeList->head;
+		freeList->head = elem->next;
+		result = elem;
+	} else {
+		AllocElem *block;
+		freeList->blockCount += 1;
+		freeList->blocks = (AllocElem **) ckrealloc((char *) freeList->blocks, sizeof(AllocElem *) * freeList->blockCount);
+		block = (AllocElem *) ckalloc((sizeof(AllocElem) - 1 + size) * ALLOC_BLOCK_SIZE);
+		freeList->blocks[freeList->blockCount - 1] = block;
+/* dbwin("AllocHax_Alloc alloc %d of size %d\n", ALLOC_BLOCK_SIZE, size); */
+		freeList->head = block;
+		elem = freeList->head;
+		for (i = 1; i < ALLOC_BLOCK_SIZE - 1; i++) {
+			elem->free = 1;
+			elem->next = (AllocElem *) (((char *) freeList->head) + (sizeof(AllocElem) - 1 + size) * i);
+			elem = elem->next;
+		}
+		elem->next = NULL;
+		elem->free = 1;
+		result = freeList->head;
+		freeList->head = result->next;
+	}
+
+	if (!result->free)
+		panic("AllocHax_Alloc: element not marked free");
+
+	result->free = 0;
+	return result->d;
+}
+
+void AllocHax_Free(ClientData data, char *ptr, int size)
+{
+	AllocList *freeLists = ((AllocData *) data)->freeLists;
+	AllocList *freeList = freeLists;
+	AllocElem *elem = (AllocElem *) (ptr - sizeof(AllocElem) + sizeof(int));
+
+	if (elem->free)
+		panic("AllocHax_Free: element already marked free");
+
+	while (freeList != NULL && freeList->size != size)
+		freeList = freeList->next;
+memset(ptr, 0xAA, size);
+	elem->next = freeList->head;
+	elem->free = 1;
+	freeList->head = elem;
+}
+
+char *AllocHax_CAlloc(ClientData data, int size, int count, int roundUp)
+{
+	int n = (count / roundUp) * roundUp + ((count % roundUp) ? roundUp : 0);
+	return AllocHax_Alloc(data, size * n);
+}
+
+void AllocHax_CFree(ClientData data, char *ptr, int size, int count, int roundUp)
+{
+	int n = (count / roundUp) * roundUp + ((count % roundUp) ? roundUp : 0);
+	AllocHax_Free(data, ptr, size * n);
+}
+
+ClientData AllocHax_Init(void)
+{
+	AllocData *data = (AllocData *) ckalloc(sizeof(AllocData));
+	data->freeLists = NULL;
+	return data;
+}
+
+void AllocHax_Finalize(ClientData data)
+{
+	AllocList *freeList = ((AllocData *) data)->freeLists;
+	int i;
+
+	while (freeList != NULL) {
+		AllocList *nextList = freeList->next;
+		for (i = 0; i < freeList->blockCount; i++) {
+			AllocElem *block = freeList->blocks[i];
+			ckfree((char *) block);
+		}
+		ckfree((char *) freeList->blocks);
+		ckfree((char *) freeList);
+		freeList = nextList;
+	}
+
+	ckfree((char *) data);
+}
+
+#endif /* ALLOC_HAX */