[frontierkernel-commits] Frontier/Common/source arraylist.c,1.1.2.5,1.1.2.6

[Andre R. <and...@us...>]

Update of /cvsroot/frontierkernel/Frontier/Common/source
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30901/Common/source

Modified Files:
      Tag: New_Tables_Experiment-branch
	arraylist.c 
Log Message:
Recycle list handles instead of disposing, at least up to a certain size.


Index: arraylist.c
===================================================================
RCS file: /cvsroot/frontierkernel/Frontier/Common/source/Attic/arraylist.c,v
retrieving revision 1.1.2.5
retrieving revision 1.1.2.6
diff -C2 -d -r1.1.2.5 -r1.1.2.6
*** arraylist.c	19 Nov 2004 11:55:39 -0000	1.1.2.5
--- arraylist.c	20 Nov 2004 18:53:20 -0000	1.1.2.6
***************
*** 66,69 ****
--- 66,71 ----
  	
  	Our public interface remains unchanged.
+ 	
+ 	2004-11-20 aradke: recycle lists
  */
  
***************
*** 88,91 ****
--- 90,110 ----
  
  
+ #define flrecyclefreelists	1	/*2004-11-20 aradke*/
+ 
+ #ifdef flrecyclefreelists
+ 	
+ 	#define maxfreelistlogsize 14
+ 	
+ 	static hdllist hfreelists[maxfreelistlogsize];
+ 
+ 	#ifdef fldebug
+ 		static int hdebuglistsallocated[maxfreelistlogsize];
+ 
+ 		static int hdebuglistsrecycled[maxfreelistlogsize];
+ 	#endif
+ 
+ #endif
+ 
+ 
  static long getlogsize (long n) {
  
***************
*** 306,329 ****
  	return (true);
  	} /*unwraplist*/
  	
  
  boolean newgrowinglist (hdllist *hlist, long ctitems) {
  	
  	hdllist h;
! 	long newlogsize = getlogsize (ctitems);
! 	long ctallocate = 1 << newlogsize;
! 		
! 	if (!newhandle (sizeof(tylist) + ctallocate * sizeof(Handle), (Handle*) &h))
! 		return (false);
! 	
! 	(**h).ctitems = 0;
  	
! 	(**h).logsize = newlogsize;
  	
! 	(**h).ix_mask = ctallocate - 1;
  
! 	(**h).ix_offset = 0;
  
! 	(**h).disposeitemcallback = nil;
  	
  	*hlist = h;
--- 325,380 ----
  	return (true);
  	} /*unwraplist*/
+ 
+ 
+ static void initlist (hdllist h, long logsize) {
+ 
+ 	(**h).ctitems = 0;
  	
+ 	(**h).logsize = logsize;
+ 	
+ 	(**h).ix_mask = (1 << logsize) - 1;
+ 
+ 	(**h).ix_offset = 0;
+ 
+ 	(**h).disposeitemcallback = nil;
+ 	} /*initlist*/
+ 
  
  boolean newgrowinglist (hdllist *hlist, long ctitems) {
  	
  	hdllist h;
! 	long logsize = getlogsize (ctitems);
  	
! 	#ifdef flrecyclefreelists
! 
! 	if (logsize < maxfreelistlogsize) {
  	
! 		if ((h = hfreelists[logsize]) != nil) {
! 		
! 			assert (gethandlesize ((Handle) h) == sizeof (tylist) + sizeof (Handle) * (1 << logsize));
  
! 			hfreelists[logsize] = (hdllist) (**h).item[0]; /*pop from stack*/
! 			
! 			initlist (h, logsize);
! 			
! 			*hlist = h;
  
! 			#ifdef fldebug
! 				hdebuglistsrecycled[logsize]++;
! 			#endif
! 			
! 			return (true);
! 			}
! 
! 		#ifdef fldebug
! 			hdebuglistsallocated[logsize]++;
! 		#endif
! 		}
! 	#endif
! 		
! 	if (!newhandle (sizeof(tylist) + (1 << logsize) * sizeof(Handle), (Handle*) &h))
! 		return (false);
! 	
! 	initlist (h, logsize);
  	
  	*hlist = h;
***************
*** 341,354 ****
  void disposelist (hdllist hlist) {
  	
! 	if (hlist != nil) {
  		
! 		listclear (hlist); /*for dispose callback*/
  		
! 		disposehandle ((Handle) hlist);
! 		}
  		
  	} /*disposelist*/
  
  
  void listclear (hdllist hlist) {
  
--- 392,450 ----
  void disposelist (hdllist hlist) {
  	
! 	#ifdef flrecyclefreelists
! 		long logsize;
! 	#endif
! 	
! 	if (hlist == nil)
! 		return;
  		
! 	listclear (hlist); /*for dispose callback*/
! 	
! 	#ifdef flrecyclefreelists
  		
! 		logsize = (**hlist).logsize;
  		
+ 		assert (gethandlesize ((Handle) hlist) == (sizeof (tylist) + sizeof (Handle) * (1 << logsize))); 
+ 
+ 		if (logsize < maxfreelistlogsize) {
+ 			
+ 			(**hlist).item[0] = (Handle) hfreelists[logsize];
+ 			
+ 			hfreelists[logsize] = hlist;
+ 			
+ 			return;
+ 			}
+ 	
+ 	#endif
+ 	
+ 	disposehandle ((Handle) hlist);
  	} /*disposelist*/
  
  
+ boolean listflushcache (long *ctbytesneeded) {
+ 	
+ 	#ifdef flrecyclefreelists
+ 
+ 	hdllist h;
+ 	long k;
+ 	
+ 	for (k = 0; k < maxfreelistlogsize; k++) {
+ 	
+ 		for (h = (hdllist) hfreelists[k]; h != nil; h = (hdllist) hfreelists[k]) {
+ 			
+ 			hfreelists[k] = (hdllist) (**h).item[0];
+ 		
+ 			*ctbytesneeded -= gethandlesize ((Handle) h);
+ 			
+ 			disposehandle ((Handle) h);
+ 			} /*for*/
+ 		} /*for*/
+ 
+ 	#endif
+ 	
+ 	return (true);
+ 	} /*listflushcache*/
+ 
+ 
  void listclear (hdllist hlist) {
  
***************
*** 373,376 ****
--- 469,474 ----
  
  	(**hlist).ctitems = 0;
+ 	
+ 	(**hlist).ix_offset = 0;
  	} /*listclear*/