[Python-checkins] python/dist/src/Parser node.c,2.16,2.16.26.1

[tim_one@users.sourceforge.net]

Update of /cvsroot/python/python/dist/src/Parser
In directory usw-pr-cvs1:/tmp/cvs-serv30495/Parser

Modified Files:
      Tag: release22-maint
	node.c 
Log Message:
PyNode_AddChild():  Backporting an aggressive over-allocation policy
when a parse node grows a very large number of children.  This sidesteps
platform realloc() disasters on several platforms.


Index: node.c
===================================================================
RCS file: /cvsroot/python/python/dist/src/Parser/node.c,v
retrieving revision 2.16
retrieving revision 2.16.26.1
diff -C2 -d -r2.16 -r2.16.26.1
*** node.c	26 Sep 2000 06:11:54 -0000	2.16
--- node.c	8 Jul 2002 19:35:56 -0000	2.16.26.1
***************
*** 19,41 ****
  }
  
! #define XXX 3 /* Node alignment factor to speed up realloc */
! #define XXXROUNDUP(n) ((n) == 1 ? 1 : ((n) + XXX - 1) / XXX * XXX)
  
  int
  PyNode_AddChild(register node *n1, int type, char *str, int lineno)
  {
! 	register int nch = n1->n_nchildren;
! 	register int nch1 = nch+1;
! 	register node *n;
  	if (nch == INT_MAX || nch < 0)
  		return E_OVERFLOW;
! 	if (XXXROUNDUP(nch) < nch1) {
  		n = n1->n_child;
! 		nch1 = XXXROUNDUP(nch1);
! 		PyMem_RESIZE(n, node, nch1);
  		if (n == NULL)
  			return E_NOMEM;
  		n1->n_child = n;
  	}
  	n = &n1->n_child[n1->n_nchildren++];
  	n->n_type = type;
--- 19,79 ----
  }
  
! /* See comments at XXXROUNDUP below.  Returns -1 on overflow. */
! static int
! fancy_roundup(int n)
! {
! 	/* Round up to the closest power of 2 >= n. */
! 	int result = 256;
! 	assert(n > 128);
! 	while (result < n) {
! 		result <<= 1;
! 		if (result <= 0)
! 			return -1;
! 	}
! 	return result;
! }
! 
! /* A gimmick to make massive numbers of reallocs quicker.  The result is
!  * a number >= the input.  For n=0 we must return 0.
!  * For n=1, we return 1, to avoid wasting memory in common 1-child nodes
!  * (XXX are those actually common?).
!  * Else for n <= 128, round up to the closest multiple of 4.  Why 4?
!  * Rounding up to a multiple of an exact power of 2 is very efficient.
!  * Else call fancy_roundup() to grow proportionately to n.  We've got an
!  * extreme case then (like test_longexp.py), and on many platforms doing
!  * anything less than proportional growth leads to exorbitant runtime
!  * (e.g., MacPython), or extreme fragmentation of user address space (e.g.,
!  * Win98).
!  * This would be straightforward if a node stored its current capacity.  The
!  * code is tricky to avoid that.
!  */
! #define XXXROUNDUP(n) ((n) == 1 ? 1 : \
! 		       (n) <= 128 ? (((n) + 3) & ~3) : \
! 		       fancy_roundup(n))
! 
  
  int
  PyNode_AddChild(register node *n1, int type, char *str, int lineno)
  {
! 	const int nch = n1->n_nchildren;
! 	int current_capacity;
! 	int required_capacity;
! 	node *n;
! 
  	if (nch == INT_MAX || nch < 0)
  		return E_OVERFLOW;
! 
! 	current_capacity = XXXROUNDUP(nch);
! 	required_capacity = XXXROUNDUP(nch + 1);
! 	if (current_capacity < 0 || required_capacity < 0)
! 		return E_OVERFLOW;
! 	if (current_capacity < required_capacity) {
  		n = n1->n_child;
! 		PyMem_RESIZE(n, node, required_capacity);
  		if (n == NULL)
  			return E_NOMEM;
  		n1->n_child = n;
  	}
+ 
  	n = &n1->n_child[n1->n_nchildren++];
  	n->n_type = type;