Version bump

sas_cxv54.asm is no longer needed.

library/GNUmakefile.68k

@@ -327,6 +327,7 @@ C_LIB = \
 	stdlib_exit.o \
 	stdlib_free.o \
 	stdlib_free_unused_slabs.o \
+	stdlib_decay_unused_slabs.o \
 	stdlib_getdefstacksize.o \
 	stdlib_getenv.o \
 	stdlib_getmemstats.o \
@@ -334,6 +335,7 @@ C_LIB = \
 	stdlib_get_errno.o \
 	stdlib_get_slab_usage.o \
 	stdlib_get_slab_allocations.o \
+	stdlib_get_slab_stats.o \
 	stdlib_isresident.o \
 	stdlib_labs.o \
 	stdlib_llabs.o \
@@ -373,6 +375,7 @@ C_LIB = \
 	stdlib_showerror.o \
 	stdlib_slab.o \
 	stdlib_slab_max_size.o \
+	stdlib_slab_purge_threshold.o \
 	stdlib_srand.o \
 	stdlib_stacksize.o \
 	stdlib_stack_usage.o \
@@ -1124,25 +1127,31 @@ $(LIBC_OBJS)/stdlib_getdefstacksize.o : stdlib_getdefstacksize.c stdlib_gcc_help
 
 $(LIBC_OBJS)/stdlib_shell_escape.o : stdlib_shell_escape.c stdlib_gcc_help.h
 
-$(LIBC_OBJS)/stdlib_alloca.o : stdlib_alloca.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_alloca.o : stdlib_alloca.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_calloc.o : stdlib_calloc.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_calloc.o : stdlib_calloc.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_free.o : stdlib_free.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_free.o : stdlib_free.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_malloc.o : stdlib_malloc.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_malloc.o : stdlib_malloc.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_slab.o : stdlib_slab.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_slab.o : stdlib_slab.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_free_unused_slabs.o : stdlib_free_unused_slabs.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_slab_purge_threshold.o : stdlib_slab_purge_threshold.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_get_slab_usage.o : stdlib_get_slab_usage.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_get_slab_stats.o : stdlib_get_slab_stats.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_get_slab_allocations.o : stdlib_get_slab_allocations.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_free_unused_slabs.o : stdlib_free_unused_slabs.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_realloc.o : stdlib_realloc.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_decay_unused_slabs.o : stdlib_decay_unused_slabs.c stdlib_memory.h include/stdlib.h
 
-$(LIBC_OBJS)/stdlib_red_black.o : stdlib_red_black.c stdlib_memory.h
+$(LIBC_OBJS)/stdlib_get_slab_usage.o : stdlib_get_slab_usage.c stdlib_memory.h include/stdlib.h
+
+$(LIBC_OBJS)/stdlib_get_slab_allocations.o : stdlib_get_slab_allocations.c stdlib_memory.h include/stdlib.h
+
+$(LIBC_OBJS)/stdlib_realloc.o : stdlib_realloc.c stdlib_memory.h include/stdlib.h
+
+$(LIBC_OBJS)/stdlib_red_black.o : stdlib_red_black.c stdlib_memory.h include/stdlib.h
 
 ##############################################################################
 

library/GNUmakefile.os4

@@ -54,7 +54,8 @@ LOG_COMMAND := 2>&1 | tee -a compiler.log
 
 WARNINGS := \
 	-Wall -W -Wpointer-arith -Wsign-compare -Wmissing-prototypes \
-	-Wundef -Wbad-function-cast -Wmissing-declarations -Wunused -Wwrite-strings
+	-Wundef -Wbad-function-cast -Wmissing-declarations -Wunused -Wwrite-strings \
+	-Wno-deprecated-declarations \
 
 #	-Wconversion -Wshadow
 

library/amiga.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"amiga.lib 1.211"
+#define VERS		"amiga.lib 1.213"
-#define VSTRING		"amiga.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"amiga.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: amiga.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: amiga.lib 1.213 (4.12.2016)"

library/amiga.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/amiga_dotimer.c

@@ -79,6 +79,8 @@ DoTimer(struct timeval *tv,LONG unit,LONG command)
 	struct MsgPort * mp;
 	LONG error;
 
+	PROFILE_OFF();
+
 	assert( tv != NULL );
 
 	#if defined(__amigaos4__)
@@ -129,14 +131,10 @@ DoTimer(struct timeval *tv,LONG unit,LONG command)
 	tr->tr_time.tv_secs		= tv->tv_secs;
 	tr->tr_time.tv_micro	= tv->tv_micro;
 
-	PROFILE_OFF();
-
 	SetSignal(0,(1UL << mp->mp_SigBit));
 
 	error = DoIO((struct IORequest *)tr);
 
-	PROFILE_ON();
-
 	tv->tv_secs		= tr->tr_time.tv_secs;
 	tv->tv_micro	= tr->tr_time.tv_micro;
 
@@ -161,5 +159,7 @@ DoTimer(struct timeval *tv,LONG unit,LONG command)
 	}
 	#endif /* __amigaos4__ */
 
+	PROFILE_ON();
+
 	return(error);
 }

library/amiga_rexxvars.c

@@ -262,9 +262,8 @@ STATIC VOID
 _SetValue(struct Environment * env,struct NexxStr * value,struct Node * symbol_table_node)
 {
 	STATIC CONST UWORD code[] = { 0x4EAE,0xFFAC,0x4E75 }; /* jsr -84(a6) ; rts */
-	struct Node * result;
 
-	result = (struct Node *)EmulateTags(code,
+	EmulateTags(code,
 		ET_RegisterA0,env,
 		ET_RegisterA1,value,
 		ET_RegisterD0,symbol_table_node,

library/c.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"c.lib 1.211"
+#define VERS		"c.lib 1.213"
-#define VSTRING		"c.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"c.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: c.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: c.lib 1.213 (4.12.2016)"

library/c.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/changes

@@ -1,3 +1,49 @@
+c.lib 1.213 (4.12.2016)
+
+- Added the __decay_unused_slabs() function which brings all currently
+  empty slabs which are still protected from reuse closer to getting
+  reused or released.
+
+- The slab-test program now exercises the memory allocation functions
+  to a greater degree. Memory is allocated in random chunk sizes,
+  the allocations are resized (to other random chunk sizes),
+  33% of all allocations are randomly freed, empty slabs readied for
+  reuse then discarded. The output in JSON format now shows a bit
+  more information as to what is being done.
+
+- Rewrote __get_slab_stats() to use setjmp() and longjmp() in the
+  print() callback invocation.
+  
+- __get_slab_stats() now reports how many times a slab was reused
+  after having stuck around in the "empty slab" list.
+  
+- Changing the slab size through an environment variable is now
+  a feature of the debug build.
+
+- Small changes to allow the library to be built with SAS/C again.
+  This includes adding code to disable/re-enable profiling,
+  fixing "stdlib_profile.h" and updating the smakefiles.
+
+- Still not sure what it does, but _CXV45 now sits along with _CX25
+  and _CX35 in "sas_cxv.asm". "sas_cxv54.asm" is not needed any
+  more.
+
+- Found the last use of MEMF_PRIVATE which should have been compiled
+  only for the OS4 version.
+
+
+c.lib 1.212 (27.11.2016)
+
+- Unused slabs which get recycled are no longer reinitialized from
+  scratch if their chunk size matches what the allocator needed.
+  If the chunk size matches, the list of available chunks is
+  left unchanged, and just the various counters are reset.
+
+- Added __get_slab_stats() function.
+
+- Added support for global __slab_purge_threshold tuning variable.
+
+
 c.lib 1.211 (23.11.2016)
 
 - Added more consistency checking to the slab allocator, which is

library/debug.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"debug.lib 1.211"
+#define VERS		"debug.lib 1.213"
-#define VSTRING		"debug.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"debug.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: debug.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: debug.lib 1.213 (4.12.2016)"

library/debug.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/include/stdlib.h

@@ -173,6 +173,19 @@ extern int rand_r(unsigned int * seed);
 
 extern unsigned long __slab_max_size;
 
+/*
+ * The slab allocator will periodically free all currently unused memory.
+ * You can control how much memory should be released, instead of
+ * releasing everything.
+ *
+ * This would make the slab allocator release only up to 512 KBytes of
+ * unused memory at a time:
+ *
+ * unsigned long __slab_purge_threshold = 512 * 1024;
+ */
+
+extern unsigned long __slab_purge_threshold;
+
 /****************************************************************************/
 
 /*
@@ -188,6 +201,21 @@ extern void __free_unused_slabs(void);
 
 /****************************************************************************/
 
+/*
+ * You can accelerate the reuse of currently unused slabs by calling
+ * the __decay_unused_slabs() function. Each call decrements the decay
+ * counter until it reaches 0, at which point an unused slab can be
+ * reused instead of allocating a new slab. Also, at 0 unused slabs
+ * will be freed by the allocator.
+ *
+ * Please note that this function works within the context of the memory
+ * allocation system and is not safe to call from interrupt code. It may
+ * break a Forbid() or Disable() condition.
+ */
+extern void __decay_unused_slabs(void);
+
+/****************************************************************************/
+
 /*
  * You can obtain runtime statistics about the slab allocator by
  * invoking the __get_slab_usage() function which in turn invokes
@@ -250,6 +278,11 @@ struct __slab_usage_information
 
 	/* How many memory chunks in this slab are being used? */
 	size_t	sui_num_chunks_used;
+
+	/* How many time was this slab reused without reinitializing
+	 * it all over again from scratch?
+	 */
+	size_t	sui_num_reused;
 };
 
 /****************************************************************************/
@@ -324,6 +357,31 @@ void __get_slab_allocations(__slab_allocation_callback callback);
 
 /****************************************************************************/
 
+/*
+ * You can obtain information about the memory managed by the slab allocator,
+ * as well as additional information about the slab allocator's performance
+ * in JSON format. This format can be used for more detailed analysis.
+ *
+ * You supply a function which will be called for each line of the JSON
+ * data produced. You can store this data in a file, or in the clipboard,
+ * for later use. Your function must return 0 if it wants to be called
+ * again, or return -1 if it wants to stop (e.g. if an error occured
+ * when writing the JSON data to disk). The same "user_data" pointer which
+ * you pass to __get_slab_stats() will be passed to your callback function.
+ *
+ * Please note that this function works within the context of the memory
+ * allocation system and is not safe to call from interrupt code. It may
+ * break a Forbid() or Disable() condition.
+ */
+
+typedef int (* __slab_status_callback)(void * user_data, const char * line, size_t line_length);
+
+/****************************************************************************/
+
+extern void __get_slab_stats(void * user_data, __slab_status_callback callback);
+
+/****************************************************************************/
+
 /*
  * You can request to use the alloca() variant that actually does allocate
  * memory from the system rather than the current stack frame, which will

library/libc.gmk

@@ -212,6 +212,7 @@ C_LIB := \
 	stdlib_dosbase.o \
 	stdlib_exit.o \
 	stdlib_free.o \
+	stdlib_decay_unused_slabs.o \
 	stdlib_free_unused_slabs.o \
 	stdlib_getdefstacksize.o \
 	stdlib_getenv.o \
@@ -220,6 +221,7 @@ C_LIB := \
 	stdlib_get_errno.o \
 	stdlib_get_slab_usage.o \
 	stdlib_get_slab_allocations.o \
+	stdlib_get_slab_stats.o \
 	stdlib_isresident.o \
 	stdlib_labs.o \
 	stdlib_llabs.o \
@@ -260,6 +262,7 @@ C_LIB := \
 	stdlib_showerror.o \
 	stdlib_slab.o \
 	stdlib_slab_max_size.o \
+	stdlib_slab_purge_threshold.o \
 	stdlib_srand.o \
 	stdlib_stacksize.o \
 	stdlib_stack_usage.o \

library/m.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"m.lib 1.211"
+#define VERS		"m.lib 1.213"
-#define VSTRING		"m.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"m.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: m.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: m.lib 1.213 (4.12.2016)"

library/m.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/m881.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"m881.lib 1.211"
+#define VERS		"m881.lib 1.213"
-#define VSTRING		"m881.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"m881.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: m881.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: m881.lib 1.213 (4.12.2016)"

library/m881.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/net.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"net.lib 1.211"
+#define VERS		"net.lib 1.213"
-#define VSTRING		"net.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"net.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: net.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: net.lib 1.213 (4.12.2016)"

library/net.lib_rev.rev

@@ -1 +1 @@
-211
+213

library/sas_cxv.asm

@@ -37,6 +37,7 @@
 
 	xdef	__CXV25
 	xdef	__CXV35
+	xdef	__CXV45
 	xdef	__CXNRM5
 	xdef	__CXTAB5
 
@@ -74,6 +75,43 @@ L44:	MOVE.W	D0,D1
 	MOVEM.L	(SP)+,D2-D5/A1
 	RTS
 
+__CXV45:
+
+	MOVE.L	D0,D1
+	SWAP	D1
+	AND.W	#$7FFF,D1
+	CMP.W	#$80,D1
+	BLT	.1
+	CMP.W	#$7F80,D1
+	BGE	.3
+	ASR.L	#3,D0
+	AND.L	#$8FFFFFFF,D0
+	ADD.L	#$38000000,D0
+	SWAP	D1
+	AND.L	#7,D1
+	ROR.L	#3,D1
+.2	RTS
+
+.1	TST.L	D1
+	BEQ.S	.2
+	MOVEM.L	D2-D5,-(SP)
+	SWAP	D0
+	MOVE.W	D0,D4
+	AND.W	#$8000,D4
+	MOVE.W	#$39D0,D5
+	MOVEQ	#0,D0
+	SWAP	D1
+	JSR	__CXNRM5(PC)
+	MOVEM.L	(SP)+,D2-D5
+	RTS
+
+.3	ASR.L	#3,D0
+	OR.L	#$7FF00000,D0
+	SWAP	D1
+	AND.L	#7,D1
+	ROR.L	#3,D1
+	RTS
+
 __CXNRM5:
 
 	CMP.L	#$20,D0

library/sas_cxv52.asm

@@ -0,0 +1,106 @@
+*
+* :ts=8
+*
+* Adapted from reassembled SAS/C runtime library code.
+*
+* Portable ISO 'C' (1994) runtime library for the Amiga computer
+* Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+*
+*   - Redistributions of source code must retain the above copyright
+*     notice, this list of conditions and the following disclaimer.
+*
+*   - Neither the name of Olaf Barthel nor the names of contributors
+*     may be used to endorse or promote products derived from this
+*     software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*
+
+	xdef	__CXV52
+	xdef	__CXV53
+
+	xref	__CXFERR
+
+	section	text,code
+
+__CXV52:
+
+	MOVEM.L	D2/D3,-(SP)
+	MOVEQ	#-1,D3
+	MOVE.L	D0,D2
+	BPL.W	lab04A
+	CMPI.L	#$BFF00000,D0
+	BCS.W	lab07A
+	MOVEM.L	D0/D1/A0/A1,-(SP)
+	PEA	(2).L
+	JSR	__CXFERR
+	ADDQ.W	#4,SP
+	MOVEM.L	(SP)+,D0/D1/A0/A1
+	BRA.W	lab07A
+
+__CXV53:
+
+	MOVEM.L	D2/D3,-(SP)
+	MOVE.L	#$7FFFFFFF,D3
+	MOVE.L	D0,D2
+	BPL.W	lab04A
+	ADDQ.L	#1,D3
+	EOR.L	D3,D0
+lab04A:	SWAP	D0
+	MOVE.W	D0,D2
+	ANDI.W	#$7FF0,D2
+	EOR.W	D2,D0
+	SUBI.W	#$3FF0,D2
+	BLT.W	lab07A
+	EORI.W	#$10,D0
+	SWAP	D0
+	ASR.W	#4,D2
+	SUBI.W	#$14,D2
+	BGT.W	lab09A
+	NEG.W	D2
+	LSR.L	D2,D0
+	TST.L	D2
+	BMI.W	lab0B2
+	BRA.W	lab0B4
+
+lab07A:	MOVEQ	#0,D0
+	BRA.W	lab0B4
+
+lab080:	MOVEM.L	D0/D1/A0/A1,-(SP)
+	PEA	(2).L
+	JSR	__CXFERR
+	ADDQ.W	#4,SP
+	MOVEM.L	(SP)+,D0/D1/A0/A1
+	MOVE.L	D3,D0
+	BRA.W	lab0B4
+
+lab09A:	CMPI.W	#11,D2
+	BGT.B	lab080
+	EOR.L	D1,D0
+	ROL.L	D2,D0
+	LSL.L	D2,D1
+	EOR.L	D1,D0
+	CMP.L	D3,D0
+	BHI.B	lab080
+	TST.L	D2
+	BPL.W	lab0B4
+lab0B2:	NEG.L	D0
+lab0B4:	MOVEM.L	(SP)+,D2/D3
+	RTS
+
+	end

library/sas_cxv54.asm

@@ -1,6 +1,4 @@
 *
-* $Id: sas_cxv54.asm,v 1.1.1.1 2004-07-26 16:31:04 obarthel Exp $
-*
 * :ts=8
 *
 * Adapted from reassembled SAS/C runtime library code.
@@ -38,7 +36,8 @@
 	xdef	__CXV54
 	xref	__CXFERR
 
-__CXV54
+__CXV54:
+
 	MOVEM.L	A0/A1,-(SP)
 	MOVE.L	D4,A0
 	SWAP	D0
@@ -47,11 +46,11 @@ __CXV54
 	EOR.W	D4,D0
 	SUB.W	#$3800,D0
 	CMP.W	#$10,D0
-	BLT	lbC000098
+	BLT	lab098
 	CMP.W	#$FEF,D0
-	BLT	lbC000102
+	BLT	lab102
 	CMP.W	#$47F0,D0
-	BLT	lbC000058
+	BLT	lab058
 	SWAP	D0
 	LSL.L	#3,D0
 	ROL.L	#3,D1
@@ -59,17 +58,16 @@ __CXV54
 	EOR.L	D1,D0
 	SWAP	D0
 	OR.W	#$7F80,D0
-	BRA	lbC000112
+	BRA	lab112
 
-lbC000058
+lab058:	CMP.W	#$FF0,D0
-	CMP.W	#$FF0,D0
+	BGE	lab074
-	BGE	lbC000074
 	CMP.L	#$FFFF0FEF,D0
-	BNE	lbC000102
+	BNE	lab102
 	CMP.L	#$F0000000,D1
-	BCS	lbC000102
+	BCS	lab102
-lbC000074
+
-	MOVEM.L	D0/D1/A0/A1,-(SP)
+lab074:	MOVEM.L	D0/D1/A0/A1,-(SP)
 	PEA	2.L
 	JSR	__CXFERR
 	ADDQ.W	#4,SP
@@ -78,63 +76,56 @@ lbC000074
 	EOR.W	D4,D0
 	SWAP	D0
 	MOVEQ	#0,D1
-	BRA	lbC000116
+	BRA	lab116
 
-lbC000098
+lab098:	CMP.W	#$FE90,D0
-	CMP.W	#$FE90,D0
+	BGE	lab0C4
-	BGE	lbC0000C4
 	ADD.W	#$3800,D0
 	OR.L	D1,D0
-	BEQ	lbC000112
+	BEQ	lab112
 	MOVEM.L	D0/D1/A0/A1,-(SP)
 	PEA	1.L
 	JSR	__CXFERR
 	ADDQ.W	#4,SP
 	MOVEM.L	(SP)+,D0/D1/A0/A1
 	MOVEQ	#0,D0
-	BRA	lbC000112
+	BRA	lab112
 
-lbC0000C4
+lab0C4:	MOVE.L	D5,A1
-	MOVE.L	D5,A1
 	MOVE.W	D0,D5
 	AND.W	#15,D0
 	EOR.W	#$10,D0
 	SWAP	D0
 	ASR.W	#4,D5
 	ADDQ.W	#2,D5
-	BGE	lbC0000E6
+	BGE	lab0E6
 	NEG.W	D5
 	LSR.L	D5,D0
 	MOVEQ	#0,D5
 	ADDX.L	D5,D0
-	BRA	lbC0000F6
+	BRA	lab0F6
 
-lbC0000E6
+lab0E6:	CLR.W	D1
-	CLR.W	D1
 	LSL.L	D5,D0
 	ADDQ.W	#1,D5
 	ROXL.L	D5,D1
 	AND.L	#15,D1
 	ADDX.L	D1,D0
-lbC0000F6
+lab0F6:	MOVE.L	A1,D5
-	MOVE.L	A1,D5
 	SWAP	D0
 	EOR.W	D4,D0
 	SWAP	D0
-	BRA	lbC000116
+	BRA	lab116
 
-lbC000102
+lab102:	SWAP	D0
-	SWAP	D0
 	LSL.L	#3,D0
 	ROXL.L	#4,D1
 	AND.L	#7,D1
 	ADDX.L	D1,D0
 	SWAP	D0
-lbC000112
+lab112:	EOR.W	D4,D0
-	EOR.W	D4,D0
 	SWAP	D0
-lbC000116
+lab116:	MOVE.L	A0,D4
-	MOVE.L	A0,D4
 	MOVEM.L	(SP)+,A0/A1
 	RTS
 

library/stdlib_decay_unused_slabs.c

@@ -0,0 +1,75 @@
+/*
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _STDLIB_HEADERS_H
+#include "stdlib_headers.h"
+#endif /* _STDLIB_HEADERS_H */
+
+/****************************************************************************/
+
+#ifndef _STDLIB_MEMORY_H
+#include "stdlib_memory.h"
+#endif /* _STDLIB_MEMORY_H */
+
+/****************************************************************************/
+
+/* Look at all currently unused slabs, decrementing the decay
+ * counter which prevents them from being reused.
+ */
+void
+__decay_unused_slabs(void)
+{
+	if(__slab_data.sd_InUse)
+	{
+		struct MinNode * free_node;
+		struct MinNode * free_node_next;
+		struct SlabNode * sn;
+
+		__memory_lock();
+
+		for(free_node = (struct MinNode *)__slab_data.sd_EmptySlabs.mlh_Head ; 
+		    free_node->mln_Succ != NULL ;
+		    free_node = free_node_next)
+		{
+			free_node_next = (struct MinNode *)free_node->mln_Succ;
+
+			/* free_node points to SlabNode.sn_EmptyLink, which
+			 * directly follows the SlabNode.sn_MinNode.
+			 */
+			sn = (struct SlabNode *)&free_node[-1];
+
+			if(sn->sn_EmptyDecay > 0)
+				sn->sn_EmptyDecay--;
+		}
+
+		__memory_unlock();
+	}
+}

library/stdlib_free.c

@@ -374,44 +374,57 @@ remove_and_free_memory_node(struct MemoryNode * mn)
 	#if defined(__USE_SLAB_ALLOCATOR)
 	{
 		/* Are we using the slab allocator? */
-		if (__slab_data.sd_InUse)
+		if(__slab_data.sd_InUse)
 		{
 			__slab_free(mn,allocation_size);
 		}
-		else if (__memory_pool != NULL)
-		{
-			FreePooled(__memory_pool,mn,allocation_size);
-		}
 		else
 		{
-			#if defined(__MEM_DEBUG)
+			if(__memory_pool != NULL)
 			{
-				FreeMem(mn,allocation_size);
+				PROFILE_OFF();
+				FreePooled(__memory_pool,mn,allocation_size);
+				PROFILE_ON();
 			}
-			#else
+			else
 			{
-				struct MinNode * mln = (struct MinNode *)mn;
+				#if defined(__MEM_DEBUG)
+				{
+					PROFILE_OFF();
+					FreeMem(mn,allocation_size);
+					PROFILE_ON();
+				}
+				#else
+				{
+					struct MinNode * mln = (struct MinNode *)mn;
 
-				mln--;
+					mln--;
 
-				Remove((struct Node *)mln);
+					Remove((struct Node *)mln);
 
-				FreeMem(mln,sizeof(*mln) + allocation_size);
+					PROFILE_OFF();
+					FreeMem(mln,sizeof(*mln) + allocation_size);
+					PROFILE_ON();
+				}
+				#endif /* __MEM_DEBUG */
 			}
-			#endif /* __MEM_DEBUG */
 		}
 	}
 	#else
 	{
-		if (__memory_pool != NULL)
+		if(__memory_pool != NULL)
 		{
+			PROFILE_OFF();
 			FreePooled(__memory_pool,mn,allocation_size);
+			PROFILE_ON();
 		}
 		else
 		{
 			#if defined(__MEM_DEBUG)
 			{
+				PROFILE_OFF();
 				FreeMem(mn,allocation_size);
+				PROFILE_ON();
 			}
 			#else
 			{
@@ -421,7 +434,9 @@ remove_and_free_memory_node(struct MemoryNode * mn)
 
 				Remove((struct Node *)mln);
 
+				PROFILE_OFF();
 				FreeMem(mln,sizeof(*mln) + allocation_size);
+				PROFILE_ON();
 			}
 			#endif /* __MEM_DEBUG */
 		}

library/stdlib_free_unused_slabs.c

@@ -72,7 +72,9 @@ __free_unused_slabs(void)
 			/* Unlink from list of slabs of the same size. */
 			Remove((struct Node *)sn);
 
+			PROFILE_OFF();
 			FreeVec(sn);
+			PROFILE_ON();
 		}
 
 		__memory_unlock();

library/stdlib_get_slab_stats.c

@@ -0,0 +1,206 @@
+/*
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _STDLIB_HEADERS_H
+#include "stdlib_headers.h"
+#endif /* _STDLIB_HEADERS_H */
+
+/****************************************************************************/
+
+#ifndef _STDLIB_MEMORY_H
+#include "stdlib_memory.h"
+#endif /* _STDLIB_MEMORY_H */
+
+/****************************************************************************/
+
+#include <setjmp.h>
+
+/****************************************************************************/
+
+struct context
+{
+	jmp_buf					abort_buf;
+	void *					user_data;
+	__slab_status_callback	callback;
+	char *					buffer;
+	size_t					buffer_size;
+};
+
+/****************************************************************************/
+
+static void print(struct context * ct, const char * format, ...)
+{
+	va_list args;
+	int len;
+
+	va_start(args,format);
+	len = vsnprintf(ct->buffer, ct->buffer_size, format, args);
+	va_end(args);
+
+	/* This shouldn't happen: the buffer ought to be large enough
+	 * to hold every single line.
+	 */
+	if(len >= (int)ct->buffer_size)
+		len = strlen(ct->buffer);
+
+	if((*ct->callback)(ct->user_data, ct->buffer, len) != 0)
+		longjmp(ct->abort_buf,-1);
+}
+
+/****************************************************************************/
+
+void
+__get_slab_stats(void * user_data, __slab_status_callback callback)
+{
+	if(__slab_data.sd_InUse)
+	{
+		static int times_checked = 1;
+
+		const struct SlabNode * sn;
+		volatile size_t num_empty_slabs = 0;
+		volatile size_t num_full_slabs = 0;
+		volatile size_t num_slabs = 0;
+		volatile size_t slab_allocation_size = 0;
+		volatile size_t total_slab_allocation_size = 0;
+		struct context ct;
+		char line[1024];
+		char time_buffer[40];
+		time_t now;
+		struct tm when;
+		int i;
+
+ 		memset(&ct, 0, sizeof(ct));
+
+		ct.user_data	= user_data;
+		ct.callback		= callback;
+		ct.buffer		= line;
+		ct.buffer_size	= sizeof(line);
+
+		__memory_lock();
+
+		if(setjmp(ct.abort_buf) == 0)
+		{
+			now = time(NULL);
+			localtime_r(&now, &when);
+
+			strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", &when);
+
+			print(&ct,"{\n");
+
+			print(&ct,"\t\"when\": \"%s\",\n", time_buffer);
+			print(&ct,"\t\"times_checked\": %d,\n", times_checked++);
+			print(&ct,"\t\"slab_size\": %zu,\n", __slab_data.sd_StandardSlabSize);
+			print(&ct,"\t\"num_single_allocations\": %zu,\n", __slab_data.sd_NumSingleAllocations);
+			print(&ct,"\t\"total_single_allocation_size\": %zu,\n", __slab_data.sd_TotalSingleAllocationSize);
+
+			if(__slab_data.sd_SingleAllocations.mlh_Head->mln_Succ != NULL)
+			{
+				const struct SlabSingleAllocation * ssa;
+
+				print(&ct,"\t\"single_allocations\": [\n");
+
+				for(ssa = (struct SlabSingleAllocation *)__slab_data.sd_SingleAllocations.mlh_Head ;
+				    ssa->ssa_MinNode.mln_Succ != NULL ;
+				    ssa = (struct SlabSingleAllocation *)ssa->ssa_MinNode.mln_Succ)
+				{
+					print(&ct,"\t\t{ \"size\": %lu, \"total_size\": %lu }%s\n",
+						ssa->ssa_Size - sizeof(*ssa), ssa->ssa_Size,
+						ssa->ssa_MinNode.mln_Succ->mln_Succ != NULL ? "," : "");
+				}
+
+				print(&ct,"\t],\n");
+			}
+			else
+			{
+				print(&ct,"\t\"single_allocations\": [],\n");
+			}
+
+			for(i = 0 ; i < (int)NUM_ENTRIES(__slab_data.sd_Slabs) ; i++)
+			{
+				for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head ;
+				    sn->sn_MinNode.mln_Succ != NULL ;
+				    sn = (struct SlabNode *)sn->sn_MinNode.mln_Succ)
+				{
+					if (sn->sn_UseCount == 0)
+						num_empty_slabs++;
+					else if (sn->sn_UseCount == sn->sn_Count)
+						num_full_slabs++;
+
+					num_slabs++;
+
+					slab_allocation_size += sn->sn_ChunkSize * sn->sn_UseCount;
+					total_slab_allocation_size += sizeof(*sn) + __slab_data.sd_StandardSlabSize;
+				}
+			}
+
+			print(&ct,"\t\"num_slabs\": %zu,\n", num_slabs);
+			print(&ct,"\t\"num_empty_slabs\": %zu,\n", num_empty_slabs);
+			print(&ct,"\t\"num_full_slabs\": %zu,\n", num_full_slabs);
+			print(&ct,"\t\"slab_allocation_size\": %zu,\n", slab_allocation_size);
+			print(&ct,"\t\"total_slab_allocation_size\": %zu,\n", total_slab_allocation_size);
+
+			if(num_slabs > 0)
+			{
+				const char * eol = "";
+	
+				print(&ct,"\t\"slabs\": [\n");
+	
+				for(i = 0 ; i < (int)NUM_ENTRIES(__slab_data.sd_Slabs) ; i++)
+				{
+					for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head ;
+					    sn->sn_MinNode.mln_Succ != NULL ;
+					    sn = (struct SlabNode *)sn->sn_MinNode.mln_Succ)
+					{
+						print(&ct,"%s\t\t{ \"size\": %lu, \"chunks\": %lu, \"chunks_in_use\": %lu, \"times_reused\": %lu, \"empty_decay\": %lu }",
+							eol,
+							sn->sn_ChunkSize,
+							sn->sn_Count,
+							sn->sn_UseCount,
+							sn->sn_NumReused,
+							sn->sn_EmptyDecay);
+	
+						eol = ",\n";
+					}
+				}
+	
+				print(&ct,"\n\t]\n");
+			}
+			else
+			{
+				print(&ct,"\t\"slabs\": []\n");
+			}
+	
+			print(&ct,"}\n");
+		}
+
+		__memory_unlock();
+	}
+}

library/stdlib_get_slab_usage.c

@@ -87,6 +87,7 @@ __get_slab_usage(__slab_usage_callback callback)
 					sui.sui_chunk_size		= sn->sn_ChunkSize;
 					sui.sui_num_chunks		= sn->sn_Count;
 					sui.sui_num_chunks_used	= sn->sn_UseCount;
+					sui.sui_num_reused		= sn->sn_NumReused;
 
 					sui.sui_slab_index++;
 

library/stdlib_lldiv.c

@@ -37,6 +37,10 @@
 
 /****************************************************************************/
 
+#if defined(__GNUC__) || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
+
+/****************************************************************************/
+
 lldiv_t
 lldiv(long long n,long long d)
 {
@@ -49,3 +53,7 @@ lldiv(long long n,long long d)
 
 	return(result);
 }
+
+/****************************************************************************/
+
+#endif

library/stdlib_main.c

@@ -117,9 +117,20 @@ call_main(void)
 			struct Process * this_process = (struct Process *)FindTask(NULL);
 			UBYTE * arg_str = GetArgStr();
 			size_t arg_str_len = strlen(arg_str);
-			UBYTE * arg_str_copy = AllocVec(arg_str_len+1,MEMF_PRIVATE);
+			UBYTE * arg_str_copy;
 			UBYTE current_dir_name[256];
 
+			#if defined(__amigaos4__)
+			{
+				arg_str_copy = AllocVec(arg_str_len+1,MEMF_PRIVATE);
+			}
+			#else
+			{
+				arg_str_copy = AllocVec(arg_str_len+1,MEMF_ANY);
+			}
+			#endif /* __amigaos4__ */
+
+
 			if(arg_str_copy != NULL && NameFromLock(this_process->pr_CurrentDir,current_dir_name,sizeof(current_dir_name)))
 			{
 				strcpy(arg_str_copy,arg_str);

library/stdlib_malloc.c

@@ -147,56 +147,73 @@ __allocate_memory(size_t size,BOOL never_free,const char * UNUSED debug_file_nam
 	#if defined(__USE_SLAB_ALLOCATOR)
 	{
 		/* Are we using the slab allocator? */
-		if (__slab_data.sd_InUse)
+		if(__slab_data.sd_InUse)
 		{
 			mn = __slab_allocate(allocation_size);
 		}
-		else if (__memory_pool != NULL)
-		{
-			mn = AllocPooled(__memory_pool,allocation_size);
-		}
 		else
 		{
-			#ifdef __MEM_DEBUG
+			if (__memory_pool != NULL)
 			{
-				mn = AllocMem(allocation_size,MEMF_ANY);
+				PROFILE_OFF();
+				mn = AllocPooled(__memory_pool,allocation_size);
+				PROFILE_ON();
 			}
-			#else
+			else
 			{
-				struct MinNode * mln;
+				#ifdef __MEM_DEBUG
-
-				mln = AllocMem(sizeof(*mln) + allocation_size,MEMF_ANY);
-				if(mln != NULL)
 				{
-					AddTail((struct List *)&__memory_list,(struct Node *)mln);
+					PROFILE_OFF();
-
+					mn = AllocMem(allocation_size,MEMF_ANY);
-					mn = (struct MemoryNode *)&mln[1];
+					PROFILE_ON();
 				}
-				else
+				#else
 				{
-					mn = NULL;
+					struct MinNode * mln;
+
+					PROFILE_OFF();
+					mln = AllocMem(sizeof(*mln) + allocation_size,MEMF_ANY);
+					PROFILE_ON();
+
+					if(mln != NULL)
+					{
+						AddTail((struct List *)&__memory_list,(struct Node *)mln);
+
+						mn = (struct MemoryNode *)&mln[1];
+					}
+					else
+					{
+						mn = NULL;
+					}
 				}
+				#endif /* __MEM_DEBUG */
 			}
-			#endif /* __MEM_DEBUG */
 		}
 	}
 	#else
 	{
 		if(__memory_pool != NULL)
 		{
+			PROFILE_OFF();
 			mn = AllocPooled(__memory_pool,allocation_size);
+			PROFILE_ON();
 		}
 		else
 		{
 			#ifdef __MEM_DEBUG
 			{
+				PROFILE_OFF();
 				mn = AllocMem(allocation_size,MEMF_ANY);
+				PROFILE_ON();
 			}
 			#else
 			{
 				struct MinNode * mln;
 
+				PROFILE_OFF();
 				mln = AllocMem(sizeof(*mln) + allocation_size,MEMF_ANY);
+				PROFILE_ON();
+
 				if(mln != NULL)
 				{
 					AddTail((struct List *)&__memory_list,(struct Node *)mln);
@@ -355,8 +372,12 @@ static struct SignalSemaphore * memory_semaphore;
 void
 __memory_lock(void)
 {
+	PROFILE_OFF();
+
 	if(memory_semaphore != NULL)
 		ObtainSemaphore(memory_semaphore);
+
+	PROFILE_ON();
 }
 
 /****************************************************************************/
@@ -364,8 +385,12 @@ __memory_lock(void)
 void
 __memory_unlock(void)
 {
+	PROFILE_OFF();
+
 	if(memory_semaphore != NULL)
 		ReleaseSemaphore(memory_semaphore);
+
+	PROFILE_ON();
 }
 
 /****************************************************************************/
@@ -503,7 +528,7 @@ STDLIB_CONSTRUCTOR(stdlib_memory_init)
 	#if defined(__USE_SLAB_ALLOCATOR)
 	{
 		/* ZZZ this is just for the purpose of testing */
-		#if 0
+		#if DEBUG
 		{
 			TEXT slab_size_var[20];
 

library/stdlib_memory.h

@@ -235,6 +235,11 @@ struct SlabNode
 	/* How many chunks of this slab are currently in use? */
 	ULONG			sn_UseCount;
 
+	/* How many times was this slab reused instead of allocating
+	 * it from system memory?
+	 */
+	ULONG			sn_NumReused;
+
 	/* This contains all the chunks of memory which are available
 	 * for allocation.
 	 */
@@ -286,7 +291,7 @@ struct SlabData
 	 */
 	size_t			sd_StandardSlabSize;
 
-	/* These fields kees track of how many entries there are in
+	/* These fields keep track of how many entries there are in
 	 * the sd_SingleAllocations list, and how much memory these
 	 * allocations occupy.
 	 */
@@ -303,6 +308,7 @@ struct SlabData
 
 extern struct SlabData NOCOMMON	__slab_data;
 extern unsigned long NOCOMMON	__slab_max_size;
+extern unsigned long NOCOMMON	__slab_purge_threshold;
 
 /****************************************************************************/
 

library/stdlib_profile.h

@@ -45,8 +45,8 @@
 
 /****************************************************************************/
 
-extern void ASM _PROLOG(REG(a0,char *));
+extern void __asm _PROLOG(register __a0 char *);
-extern void ASM _EPILOG(REG(a0,char *));
+extern void __asm _EPILOG(register __a0 char *);
 
 #if _PROFILE
 #define PROFILE_OFF()	_PROLOG(0L)

library/stdlib_realloc.c

@@ -31,6 +31,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+/*#define DEBUG*/
+
 #ifndef _STDLIB_HEADERS_H
 #include "stdlib_headers.h"
 #endif /* _STDLIB_HEADERS_H */
@@ -76,6 +78,7 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 #endif /* UNIX_PATH_SEMANTICS */
 	else
 	{
+		size_t old_size;
 		struct MemoryNode * mn;
 		BOOL reallocate;
 
@@ -108,29 +111,23 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 		}
 		#endif /* __MEM_DEBUG */
 
-		if(mn == NULL || mn->mn_NeverFree)
+		if(mn == NULL || FLAG_IS_SET(mn->mn_Size, MN_SIZE_NEVERFREE))
 		{
 			SHOWMSG("cannot free this chunk");
 			goto out;
 		}
 
+		old_size = GET_MN_SIZE(mn);
+
 		/* Don't do anything unless the size of the allocation
 		   has really changed. */
 		#if defined(__MEM_DEBUG)
 		{
-			reallocate = (mn->mn_Size != size);
+			reallocate = (old_size != size);
 		}
 		#else
 		{
-			size_t rounded_allocation_size;
+			if(size > old_size)
-
-			/* Round the total allocation size to the operating system
-			   granularity. */
-			rounded_allocation_size = __get_allocation_size(size);
-
-			assert( rounded_allocation_size >= size );
-
-			if(rounded_allocation_size > mn->mn_Size)
 			{
 				/* Allocation size should grow. */
 				reallocate = TRUE;
@@ -143,7 +140,7 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 				                 allocation. We also take into account that the
 				                 actual size of the allocation is affected by a
 				                 certain operating system imposed granularity. */
-				reallocate = (rounded_allocation_size < mn->mn_Size && rounded_allocation_size <= mn->mn_Size / 2);
+				reallocate = (size < old_size && size <= old_size / 2);
 			}
 		}
 		#endif /* __MEM_DEBUG */
@@ -152,7 +149,7 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 		{
 			void * new_ptr;
 
-			D(("realloc() size has changed; old=%ld, new=%ld",mn->mn_Size,size));
+			D(("realloc() size has changed; old=%ld, new=%ld",old_size,size));
 
 			/* We allocate the new memory chunk before we
 			   attempt to replace the old. */
@@ -164,8 +161,8 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 			}
 
 			/* Copy the contents of the old allocation to the new buffer. */
-			if(size > mn->mn_Size)
+			if(size > old_size)
-				size = mn->mn_Size;
+				size = old_size;
 
 			memmove(new_ptr,ptr,size);
 
@@ -177,7 +174,7 @@ __realloc(void *ptr,size_t size,const char * file,int line)
 		}
 		else
 		{
-			D(("size didn't actually change that much (%ld -> %ld); returning memory block as is.",mn->mn_Size,size));
+			D(("size didn't actually change that much (%ld -> %ld); returning memory block as is.",old_size,size));
 
 			/* No change in size. */
 			result = ptr;

library/stdlib_slab.c

@@ -85,6 +85,8 @@ __slab_allocate(size_t allocation_size)
 		/* No integer overflow? */
 		if(allocation_size < total_single_allocation_size)
 		{
+			PROFILE_OFF();
+
 			#if defined(__amigaos4__)
 			{
 				ssa = AllocMem(total_single_allocation_size,MEMF_PRIVATE);
@@ -94,6 +96,8 @@ __slab_allocate(size_t allocation_size)
 				ssa = AllocMem(total_single_allocation_size,MEMF_ANY);
 			}
 			#endif /* __amigaos4__ */
+
+			PROFILE_ON();
 		}
 		/* Integer overflow has occured. */
 		else
@@ -125,6 +129,7 @@ __slab_allocate(size_t allocation_size)
 	else
 	{
 		struct MinList * slab_list = NULL;
+		BOOL slab_reused = FALSE;
 		ULONG entry_size;
 		ULONG chunk_size;
 		int slab_index;
@@ -202,6 +207,9 @@ __slab_allocate(size_t allocation_size)
 
 						/* Pull it out of the list of slabs available for reuse. */
 						Remove((struct Node *)&sn->sn_EmptyLink);
+
+						sn->sn_EmptyDecay = 0;
+						sn->sn_NumReused++;
 					}
 
 					sn->sn_UseCount++;
@@ -252,14 +260,27 @@ __slab_allocate(size_t allocation_size)
 						/* Unlink from list of empty slabs. */
 						Remove((struct Node *)free_node);
 
-						/* Unlink from list of slabs which keep chunks
+						/* If the chunk size of the reused slab matches
-						 * of the same size. It will be added there
+						 * exactly what we need then we won't have to
-						 * again, at a different position.
+						 * completely reinitialize it again.
 						 */
-						Remove((struct Node *)sn);
+						if(sn->sn_ChunkSize == chunk_size)
+						{
+							slab_reused = TRUE;
+						}
+						else
+						{
+							/* Unlink from list of slabs which keep chunks
+							 * of the same size. It will be added there
+							 * again, at a different position.
+							 */
+							Remove((struct Node *)sn);
+						}
 
 						D(("reusing a slab"));
 
+						sn->sn_NumReused++;
+
 						new_sn = sn;
 						break;
 					}
@@ -272,6 +293,8 @@ __slab_allocate(size_t allocation_size)
 				{
 					D(("no slab is available for reuse; allocating a new slab (%lu bytes)",sizeof(*new_sn) + __slab_data.sd_StandardSlabSize));
 
+					PROFILE_OFF();
+
 					#if defined(__amigaos4__)
 					{
 						new_sn = (struct SlabNode *)AllocVec(sizeof(*new_sn) + __slab_data.sd_StandardSlabSize,MEMF_PRIVATE);
@@ -282,6 +305,8 @@ __slab_allocate(size_t allocation_size)
 					}
 					#endif /* __amigaos4__ */
 
+					PROFILE_ON();
+
 					if(new_sn == NULL)
 						D(("slab allocation failed"));
 
@@ -295,59 +320,73 @@ __slab_allocate(size_t allocation_size)
 
 				if(new_sn != NULL)
 				{
-					struct MinNode * free_chunk;
-					ULONG num_free_chunks = 0;
-					BYTE * first_byte;
-					BYTE * last_byte;
-
 					D(("setting up slab 0x%08lx", new_sn));
 
 					assert( chunk_size <= __slab_data.sd_StandardSlabSize );
 
-					memset(new_sn,0,sizeof(*new_sn));
+					/* Do we have to completely initialize this slab from scratch? */
-
+					if(NOT slab_reused)
-					NewList((struct List *)&new_sn->sn_FreeList);
-
-					/* Split up the slab memory into individual chunks
-					 * of the same size and keep track of them
-					 * in the free list. The memory managed by
-					 * this slab immediately follows the
-					 * SlabNode header.
-					 */
-					first_byte	= (BYTE *)&new_sn[1];
-					last_byte	= &first_byte[__slab_data.sd_StandardSlabSize - chunk_size];
-
-					for(free_chunk = (struct MinNode *)first_byte ;
-					    free_chunk <= (struct MinNode *)last_byte;
-					    free_chunk = (struct MinNode *)(((BYTE *)free_chunk) + chunk_size))
 					{
-						AddTail((struct List *)&new_sn->sn_FreeList, (struct Node *)free_chunk);
+						struct SlabChunk * free_chunk;
-						num_free_chunks++;
+						ULONG num_free_chunks = 0;
-					}
+						BYTE * first_byte;
+						BYTE * last_byte;
 
-					D(("slab contains %lu chunks, %lu bytes each",num_free_chunks,chunk_size));
+						memset(new_sn,0,sizeof(*new_sn));
+
+						NewList((struct List *)&new_sn->sn_FreeList);
+
+						/* This slab has room for new allocations, so make sure that
+						 * it goes to the front of the slab list. It will be used
+						 * by the next allocation request of this size.
+						 */
+						AddHead((struct List *)slab_list,(struct Node *)new_sn);
+
+						/* Split up the slab memory into individual chunks
+						 * of the same size and keep track of them
+						 * in the free list. The memory managed by
+						 * this slab immediately follows the
+						 * SlabNode header.
+						 */
+						first_byte	= (BYTE *)&new_sn[1];
+						last_byte	= &first_byte[__slab_data.sd_StandardSlabSize - chunk_size];
+
+						for(free_chunk = (struct SlabChunk *)first_byte ;
+						    free_chunk <= (struct SlabChunk *)last_byte;
+						    free_chunk = (struct SlabChunk *)(((BYTE *)free_chunk) + chunk_size))
+						{
+							AddTail((struct List *)&new_sn->sn_FreeList, (struct Node *)free_chunk);
+							num_free_chunks++;
+						}
+
+						new_sn->sn_Count		= num_free_chunks;
+						new_sn->sn_ChunkSize	= chunk_size;
+
+						D(("new slab contains %lu chunks, %lu bytes each",num_free_chunks,chunk_size));
+					}
+					/* This slab was reused and need not be reinitialized from scratch. */
+					else
+					{
+						assert( new_sn->sn_FreeList.mlh_Head != NULL );
+						assert( new_sn->sn_ChunkSize == chunk_size );
+						assert( new_sn->sn_Count == 0 );
+					}
 
 					/* Grab the first free chunk (there has to be one). */
 					chunk = (struct SlabChunk *)RemHead((struct List *)&new_sn->sn_FreeList);
 
-					assert( chunk != NULL );
-
 					/* Keep track of this chunk's parent slab. */
 					chunk->sc_Parent = new_sn;
 
+					assert( chunk != NULL );
+					assert( chunk->sc_Parent == new_sn );
+
 					allocation = &chunk[1];
 
-					D(("allocation succeeded at 0x%08lx in slab 0x%08lx (slab use count = %lu)",allocation,new_sn,new_sn->sn_UseCount+1));
+					/* This slab is now in use. */
+					new_sn->sn_UseCount = 1;
 
-					/* Set up the new slab and put it where it belongs. */
+					D(("allocation succeeded at 0x%08lx in slab 0x%08lx (slab use count = %lu)",allocation,new_sn,new_sn->sn_UseCount));
-					new_sn->sn_EmptyDecay	= 0;
-					new_sn->sn_UseCount		= 1;
-					new_sn->sn_Count		= num_free_chunks;
-					new_sn->sn_ChunkSize	= chunk_size;
-
-					SHOWVALUE(new_sn->sn_ChunkSize);
-
-					AddHead((struct List *)slab_list,(struct Node *)new_sn);
 				}
 
 				/* Mark unused slabs for purging, and purge those which
@@ -355,6 +394,8 @@ __slab_allocate(size_t allocation_size)
 				 */
 				if(purge)
 				{
+					size_t total_purged = 0;
+
 					D(("purging empty slabs"));
 
 					for(free_node = (struct MinNode *)__slab_data.sd_EmptySlabs.mlh_Head ; 
@@ -379,7 +420,18 @@ __slab_allocate(size_t allocation_size)
 							/* Unlink from list of slabs of the same size. */
 							Remove((struct Node *)sn);
 
+							PROFILE_OFF();
 							FreeVec(sn);
+							PROFILE_ON();
+
+							total_purged += sizeof(*sn) + __slab_data.sd_StandardSlabSize;
+
+							/* Stop releasing memory if we reach the threshold. If no
+							 * threshold has been set, we will free as much memory
+							 * as possible.
+							 */
+							if(__slab_purge_threshold > 0 && total_purged >= __slab_purge_threshold)
+								break;
 						}
 						/* Give it another chance. */
 						else
@@ -470,7 +522,10 @@ __slab_free(void * address,size_t allocation_size)
 		assert( size <= __slab_data.sd_TotalSingleAllocationSize );
 
 		Remove((struct Node *)ssa);
+
+		PROFILE_OFF();
 		FreeMem(ssa, size);
+		PROFILE_ON();
 
 		__slab_data.sd_NumSingleAllocations--;
 		__slab_data.sd_TotalSingleAllocationSize -= size;
@@ -700,6 +755,21 @@ __slab_init(size_t slab_size)
 
 /****************************************************************************/
 
+#if DEBUG
+
+static int print_json(void * ignore,const char * buffer,size_t len)
+{
+	extern void kputs(const char * str);
+
+	kputs(buffer);
+
+	return(0);
+}
+
+#endif /* DEBUG */
+
+/****************************************************************************/
+
 void
 __slab_exit(void)
 {
@@ -712,7 +782,19 @@ __slab_exit(void)
 		struct SlabNode * sn_next;
 		struct MinNode * mn;
 		struct MinNode * mn_next;
-		int i;
+		size_t slab_count = 0, total_slab_size = 0;
+		size_t single_allocation_count = 0, total_single_allocation_size = 0;
+		int i, j;
+
+		#if DEBUG
+		{
+			kprintf("---BEGIN JSON DATA ---\n");
+
+			__get_slab_stats(NULL, print_json);
+
+			kprintf("---END JSON DATA ---\n\n");
+		}
+		#endif /* DEBUG */
 
 		D(("freeing slabs"));
 
@@ -720,25 +802,40 @@ __slab_exit(void)
 		for(i = 0 ; i < (int)NUM_ENTRIES(__slab_data.sd_Slabs) ; i++)
 		{
 			if(__slab_data.sd_Slabs[i].mlh_Head->mln_Succ != NULL)
-				D(("freeing slab #%ld (%lu bytes per chunk)", i, (1UL << i)));
+				D(("freeing slab slot #%ld (%lu bytes per chunk)", i, (1UL << i)));
 
-			for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head ;
+			for(sn = (struct SlabNode *)__slab_data.sd_Slabs[i].mlh_Head, j = 0 ;
 			    sn->sn_MinNode.mln_Succ != NULL ;
 			    sn = sn_next)
 			{
 				sn_next = (struct SlabNode *)sn->sn_MinNode.mln_Succ;
 
+				D((" slab #%ld.%ld at 0x%08lx",i, ++j, sn));
+				D(("  fragmentation = %ld%%",100 * (__slab_data.sd_StandardSlabSize - sn->sn_Count * sn->sn_ChunkSize) / __slab_data.sd_StandardSlabSize));
+				D(("  total space used = %ld (%ld%%)",sn->sn_UseCount * sn->sn_ChunkSize, 100 * sn->sn_UseCount / sn->sn_Count));
+				D(("  number of chunks total = %ld",sn->sn_Count));
+				D(("  number of chunks used = %ld%s",sn->sn_UseCount,sn->sn_UseCount == 0 ? " (empty)" : (sn->sn_UseCount == sn->sn_Count) ? " (full)" : ""));
+				D(("  how often reused = %ld",sn->sn_NumReused));
+
+				total_slab_size += sizeof(*sn) + __slab_data.sd_StandardSlabSize;
+				slab_count++;
+
+				PROFILE_OFF();
 				FreeVec(sn);
+				PROFILE_ON();
 			}
 		}
 
+		if(slab_count > 0)
+			D(("number of slabs = %ld, total slab size = %ld bytes",slab_count, total_slab_size));
+
 		if(__slab_data.sd_SingleAllocations.mlh_Head->mln_Succ != NULL)
 			D(("freeing single allocations"));
 
 		/* Free the memory allocated for each allocation which did not
 		 * go into a slab.
 		 */
-		for(mn = __slab_data.sd_SingleAllocations.mlh_Head ;
+		for(mn = __slab_data.sd_SingleAllocations.mlh_Head, j = 0 ;
 		    mn->mln_Succ != NULL ;
 		    mn = mn_next)
 		{
@@ -746,9 +843,19 @@ __slab_exit(void)
 
 			ssa = (struct SlabSingleAllocation *)mn;
 
+			D((" allocation #%ld at 0x%08lx, %lu bytes", ++j, ssa, ssa->ssa_Size));
+
+			total_single_allocation_size += ssa->ssa_Size;
+			single_allocation_count++;
+
+			PROFILE_OFF();
 			FreeMem(ssa, ssa->ssa_Size);
+			PROFILE_ON();
 		}
 
+		if(single_allocation_count > 0)
+			D(("number of single allocations = %ld, total single allocation size = %ld", single_allocation_count, total_single_allocation_size));
+
 		__slab_data.sd_InUse = FALSE;
 	}
 

library/stdlib_slab_purge_threshold.c

@@ -0,0 +1,38 @@
+/*
+ * :ts=4
+ *
+ * Portable ISO 'C' (1994) runtime library for the Amiga computer
+ * Copyright (c) 2002-2015 by Olaf Barthel <obarthel (at) gmx.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   - Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   - Neither the name of Olaf Barthel nor the names of contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _STDLIB_HEADERS_H
+#include "stdlib_headers.h"
+#endif /* _STDLIB_HEADERS_H */
+
+/****************************************************************************/
+
+unsigned long __slab_purge_threshold;

library/unistd_getcwd.c

@@ -184,7 +184,6 @@ __getcwd(char * buffer,size_t buffer_size,const char *file,int line)
 			if(__unix_path_semantics)
 			{
 				const char * path_name = buffer;
-				size_t len;
 
 				if(__translate_amiga_to_unix_path_name(&path_name,&buffer_nti) != 0)
 					goto out;

library/unix.lib_rev.h

@@ -1,6 +1,6 @@
 #define VERSION		1
-#define REVISION	211
+#define REVISION	213
-#define DATE		"23.11.2016"
+#define DATE		"4.12.2016"
-#define VERS		"unix.lib 1.211"
+#define VERS		"unix.lib 1.213"
-#define VSTRING		"unix.lib 1.211 (23.11.2016)\r\n"
+#define VSTRING		"unix.lib 1.213 (4.12.2016)\r\n"
-#define VERSTAG		"\0$VER: unix.lib 1.211 (23.11.2016)"
+#define VERSTAG		"\0$VER: unix.lib 1.213 (4.12.2016)"

library/unix.lib_rev.rev

@@ -1 +1 @@
-211
+213

test_programs/GNUmakefile.68k

@@ -13,7 +13,7 @@ DELETE = delete all quiet
 
 .c.o:
 	@echo "Compiling $<"
-	@$(CC) -c $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 ##############################################################################
 
@@ -31,7 +31,7 @@ WARNINGS = \
 
 INCLUDE = -I../library/include
 LIB = -L../library/lib
- OPTIONS = -DNDEBUG -fno-builtin -fwritable-strings -DNO_INLINE_STDARG -DIEEE_FLOATING_POINT_SUPPORT -DVERBOSE
+ OPTIONS = -DNDEBUG -fno-builtin -fwritable-strings -DNO_INLINE_STDARG -DIEEE_FLOATING_POINT_SUPPORT -DVERBOSE=1
 #OPTIONS = -D__MEM_DEBUG -fno-builtin
 #OPTIONS = -DDEBUG -D__MEM_DEBUG -DNO_INLINE_STDARG -fno-builtin
  OPTIMIZE = -O
@@ -50,14 +50,14 @@ all: test fgets_test iotest sscanf_test printf_test sprintf_test \
 	stack_size_test translate_test strtok_test uname simple \
 	fstat_stdout_test simple_sprintf date_test sscanf_64 factorial \
 	execvp_test setlocale rand fstat_test base_dir_nametest \
-	malloc-test
+	malloc-test slab-test
 
 clean:
 	$(DELETE) #?.o #?.map test fgets_test iotest sscanf_test printf_test \
 		sprintf_test stack_size_test translate_test strtok_test uname \
 		simple fstat_stdout_test fstat_test simple_sprintf date_test sscanf_64 \
 		factorial execvp_test setlocale rand base_dir_nametest \
-		malloc-test
+		malloc-test slab-test
 
 ##############################################################################
 
@@ -145,9 +145,13 @@ rand : rand.o
 	@echo "Linking $@"
 	$(CC) $(CFLAGS) -o $@ rand.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
 
-malloc-test: malloc-test.o
+malloc-test : malloc-test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ rand.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ malloc-test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+
+slab-test : slab-test.o
+	@echo "Linking $@"
+	$(CC) $(CFLAGS) -o $@ slab-test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
 
 ##############################################################################
 

test_programs/GNUmakefile.os4

@@ -21,104 +21,120 @@ WARNINGS = \
 	-Wall -W -Wshadow -Wpointer-arith -Wsign-compare -Wmissing-prototypes \
 	-Wundef -Wbad-function-cast -Wmissing-declarations -Wconversion
 
+V = /V
 INCLUDE = -I$(V)/include -I../library/include
-LIB = -L../library/lib
+#OPTIONS = -D__MEM_DEBUG
-#OPTIONS = -DNDEBUG -fno-builtin -DNO_INLINE_STDARG -DIEEE_FLOATING_POINT_SUPPORT
+#OPTIONS = -DDEBUG
-#OPTIONS = -D__MEM_DEBUG -fno-builtin
+ OPTIONS = -DNDEBUG
- OPTIONS = -DDEBUG -DNO_INLINE_STDARG -fno-builtin
+#OPTIMIZE = -O3
-#OPTIMIZE = -O
+#DEBUG = -ggdb
-#OPTIMIZE = -O2 -fomit-frame-pointer
-DEBUG = -ggdb
 
-CFLAGS = $(WARNINGS) $(OPTIMIZE) $(DEBUG) $(OPTIONS) $(CODE_TYPE) $(INCLUDE) $(LIB)
+# Note: Because the matching startup code needs to be used for
+#       correctly linking the test programs, you need to make sure
+#       that the current development version of clib2 is visible
+#       where the linker expects it (soft link). Some more tuning would be
+#       required here because you really should not need to tinker
+#       with the location of library and the options "-L. -L../library/lib"
+#       should be sufficient.
+
+CFLAGS = -mcrt=clib2 -fno-builtin $(WARNINGS) $(OPTIMIZE) $(DEBUG) $(OPTIONS) $(INCLUDE)
+LFLAGS = -Wl,-d
 
 ##############################################################################
 
-LIBS = -lm -lc -ldebug -lgcc
+LIBS = -ldebug -lm -lc
 
 ##############################################################################
 
 all: test fgets_test iotest sscanf_test printf_test sprintf_test \
 	stack_size_test translate_test strtok_test uname simple \
 	fstat_stdout_test simple_sprintf date_test sscanf_64 \
-	factorial setlocale
+	factorial setlocale rand malloc-test slab-test
 
 clean:
 	$(DELETE) *.o *.map test fgets_test iotest sscanf_test printf_test \
 		sprintf_test stack_size_test translate_test strtok_test \
 		uname simple fstat_stdout_test simple_sprintf date_test \
-		sscanf_64 factorial setlocale rand
+		sscanf_64 factorial setlocale rand malloc-test slab-test
 
 ##############################################################################
 
 setlocale : setlocale.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ setlocale.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ setlocale.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 test : test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 date_test : date_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 fgets_test : fgets_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ fgets_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ fgets_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 strtok_test : strtok_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ strtok_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ strtok_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 iotest : iotest.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ iotest.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ iotest.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 sscanf_test : sscanf_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ sscanf_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ sscanf_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 printf_test : printf_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ printf_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ printf_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 sprintf_test : sprintf_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ sprintf_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ sprintf_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 stack_size_test : stack_size_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ stack_size_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ stack_size_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 translate_test : translate_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ translate_test.o -lunix $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ translate_test.o -lunix $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 uname : uname.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ uname.o -lunix $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ uname.o -lunix $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 simple : simple.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ simple.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ simple.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 fstat_stdout_test : fstat_stdout_test.o
 	@echo "Linking $@"
-	$(CC) $(CFLAGS) -o $@ fstat_stdout_test.o $(LIBS) -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ fstat_stdout_test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 simple_sprintf : simple_sprintf.o
 	@echo "Linking $@"
-	$(CC) -nostdlib $(CFLAGS) -o $@ simple_sprintf.o -lc -lgcc -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -nostdlib -o $@ simple_sprintf.o -lc -lgcc $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 sscanf_64 : sscanf_64.o
 	@echo "Linking $@"
-	$(CC) -nostdlib $(CFLAGS) -o $@ sscanf_64.o -lc -lgcc -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ sscanf_64.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 factorial : factorial.o
 	@echo "Linking $@"
-	$(CC) -nostdlib $(CFLAGS) -o $@ factorial.o -lc -lgcc -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ factorial.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
 
 rand : rand.o
 	@echo "Linking $@"
-	$(CC) -nostdlib $(CFLAGS) -o $@ rand.o -lc -lgcc -Wl,--cref,-M,-Map=$@.map
+	$(CC) $(CFLAGS) -o $@ rand.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
+
+malloc-test : malloc-test.o
+	@echo "Linking $@"
+	$(CC) $(CFLAGS) -o $@ malloc-test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map
+
+slab-test : slab-test.o
+	@echo "Linking $@"
+	$(CC) $(CFLAGS) -o $@ slab-test.o $(LIBS) $(LFLAGS) -Wl,--cref,-M,-Map=$@.map

test_programs/slab-test.c

@@ -0,0 +1,90 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+unsigned long __slab_max_size = 4096;
+
+static int print_json(void * ignore,const char * buffer,size_t len)
+{
+	fputs(buffer, stdout);
+
+	return(0);
+}
+
+int
+main(int argc,char ** argv)
+{
+	int num_allocations = 1000;
+	int max_allocation_size = 8192;
+	int random_free_percentage = 33;
+	char ** allocation_table;
+	char * allocation;
+	int i;
+
+	allocation_table = malloc(sizeof(*allocation_table) * num_allocations);
+	if(allocation_table == NULL)
+		exit(EXIT_FAILURE);
+
+	srand(1);
+
+	printf("/* Allocating %d random length fragments of memory (maximum size = %ld bytes). */\n", num_allocations, max_allocation_size);
+
+	for(i = 0 ; i < num_allocations ; i++)
+	{
+		allocation = malloc(1 + (rand() % max_allocation_size));
+		if(allocation == NULL)
+			exit(EXIT_FAILURE);
+
+		allocation_table[i] = allocation;
+	}
+
+	__get_slab_stats(NULL, print_json);
+
+	printf("\n/* Changing all allocations to different random lengths. */\n");
+
+	for(i = 0 ; i < num_allocations ; i++)
+	{
+		allocation = realloc(allocation_table[i], 1 + (rand() % max_allocation_size));
+		if(allocation == NULL)
+			exit(EXIT_FAILURE);
+
+		allocation_table[i] = allocation;
+	}
+
+	__get_slab_stats(NULL, print_json);
+
+	printf("\n/* Freeing %d%% of all allocations. */\n", random_free_percentage);
+
+	for(i = 0 ; i < num_allocations ; i++)
+	{
+		if((rand() % 100) < 33)
+		{
+			free(allocation_table[i]);
+			allocation_table[i] = NULL;
+		}
+	}
+
+	__get_slab_stats(NULL, print_json);
+
+	printf("\n/* Marking unused slabs for reuse; reallocating memory/changing allocation lengths. */\n");
+
+	__decay_unused_slabs();
+
+	for(i = 0 ; i < num_allocations ; i++)
+	{
+		allocation = realloc(allocation_table[i], 1 + (rand() % max_allocation_size));
+		if(allocation == NULL)
+			exit(EXIT_FAILURE);
+
+		allocation_table[i] = allocation;
+	}
+
+	__get_slab_stats(NULL, print_json);
+
+	printf("\n/* Freeing all unused slabs. */\n");
+
+	__free_unused_slabs();
+
+	__get_slab_stats(NULL, print_json);
+
+	return(EXIT_SUCCESS);
+}

test_programs/smakefile

@@ -1,6 +1,4 @@
 #
-# $Id: smakefile,v 1.9 2006-01-02 13:11:39 obarthel Exp $
-#
 # :ts=8
 #
 
@@ -10,6 +8,10 @@
 	@echo "Compiling $<"
 	@sc nover $(CFLAGS) $<
 
+.c.mo:
+	@echo "Compiling $<"
+	@sc nover $(CFLAGS) objname=$*.mo math=IEEE $<
+
 .asm.o:
 	@echo "Assembling $<"
 	@asm $(AFLAGS) $<
@@ -19,30 +21,31 @@
 # You might want to change this to the directory where your operating system
 # header files are stored. On my system, that's "V:include", but you might
 # get lucky with "sc:include" instead, which is the default for SAS/C.
-INCLUDE_DIR = V:include
+#INCLUDE_DIR = V:include
-#INCLUDE_DIR = sc:include
+INCLUDE_DIR = sc:include
 
 ##############################################################################
 
 # This is where the header files, the startup code and the c.lib files are
 # stored; see below how this prefix is used.
-LIB = /library/
+LIB = /library
+
+STARTUP = $(LIB)/startup.o
+LIBS = $(LIB)/amiga.lib $(LIB)/c.lib $(LIB)/debug.lib
+MATH_LIBS = $(LIB)/math.lib $(LIBS)
 
 ##############################################################################
 
  OPTIMIZE	= optimize opttime optschedule optinline 
 #DEBUG		= debug=line noopt define=CHECK_FOR_NULL_POINTERS
 #DEBUG		= debug=line
-#DEBUG		= debug=line define=NDEBUG
+ DEBUG		= debug=line define=NDEBUG
- DEBUG		= debug=sf noopt
+#DEBUG		= debug=sf noopt
 #DEBUG		= debug=sf noopt define=CHECK_FOR_NULL_POINTERS
 #PROFILE	= profile
  DATA		= data=faronly
 #CODE		= code=far
- CPU		= cpu=060
+ CPU		= cpu=030
-MATH		= define=IEEE_FLOATING_POINT_SUPPORT math=IEEE
-SUPPORT		= define=UNIX_PATH_SEMANTICS define=SOCKET_SUPPORT define=USERGROUP_SUPPORT \
-		  define=__C_MACROS__
 
 ##############################################################################
 
@@ -55,8 +58,9 @@ CFLAGS = \
 	nostackcheck \
 	stringmerge \
 	errorrexx \
-	$(PROFILE) $(OPTIMIZE) $(CODE) $(DATA) $(CPU) $(MATH) \
+	$(PROFILE) $(OPTIMIZE) $(CODE) $(DATA) $(CPU) $(DEBUG) \
-	$(SUPPORT) $(DEBUG)
+	math=ieee \
+	define=VERBOSE
 
 AFLAGS = \
 	-d -m2
@@ -68,19 +72,23 @@ all: \
 	test fgets_test iotest sscanf_test printf_test sprintf_test \
 	stack_size_test translate_test strtok_test uname simple \
 	fstat_stdout_test simple_sprintf date_test factorial \
+	execvp_test setlocale rand fstat_test base_dir_nametest \
+	malloc-test slab-test \
 	cleanup
 
 clean:
-	-delete \#?.o \#?.map \
+	-delete \#?.o \#?.mo \#?.map \
 		test fgets_test iotest sscanf_test printf_test sprintf_test \
 		stack_size_test translate_test strtok_test uname simple \
-		simple_sprintf date_test factorial
+		fstat_stdout_test simple_sprintf date_test factorial \
+		execvp_test setlocale rand fstat_test base_dir_nametest \
+		malloc-test slab-test
 
 ##############################################################################
 
 setup:
 	@echo "Setting up include: assignment"
-	@assign include: $(LIB)include V:include
+	@assign include: $(LIB)/include $(INCLUDE_DIR)
 
 cleanup:
 	@echo "Cleaning up include: assignment"
@@ -90,77 +98,112 @@ cleanup:
 
 test: test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 date_test: date_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o date_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 fgets_test: fgets_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o fgets_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 strtok_test: strtok_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o strtok_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 iotest: iotest.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o iotest.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
-sscanf_test: sscanf_test.o
+sscanf_test: sscanf_test.mo
 	@echo "Linking $@"
-	@slink $(LIB)startup.o sscanf_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.mo to $@ lib $(MATH_LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
-printf_test: printf_test.o
+printf_test: printf_test.mo
 	@echo "Linking $@"
-	@slink $(LIB)startup.o printf_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.mo to $@ lib $(MATH_LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 sprintf_test: sprintf_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o sprintf_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 stack_size_test: stack_size_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o stack_size_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 translate_test: translate_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o translate_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIB)/unix.lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 uname: uname.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o uname.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 simple: simple.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o simple.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 fstat_stdout_test: fstat_stdout_test.o
 	@echo "Linking $@"
-	@slink $(LIB)startup.o fstat_stdout_test.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 simple_sprintf: simple_sprintf.o
 	@echo "Linking $@"
-	@slink simple_sprintf.o to $@ lib $(LIB)c.lib addsym \
+	@slink $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
-factorial: factorial.o
+factorial: factorial.mo
 	@echo "Linking $@"
-	@slink $(LIB)startup.o factorial.o to $@ lib $(LIB)c.lib addsym \
+	@slink $(STARTUP) $*.mo to $@ lib $(MATH_LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+execvp_test: execvp_test.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIB)/unix.lib $(LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+setlocale: setlocale.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+rand: rand.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+fstat_test: fstat_test.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+base_dir_nametest: base_dir_nametest.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+malloc-test: malloc-test.mo
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.mo to $@ lib $(MATH_LIBS) addsym \
+		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
+
+slab-test: slab-test.o
+	@echo "Linking $@"
+	@slink $(STARTUP) $*.o to $@ lib $(LIBS) addsym \
 		map $@.map,fhx fwidth 32 pwidth 32 swidth 32
 
 ##############################################################################

test_programs/test.c

@@ -77,6 +77,8 @@ main(int argc,char ** argv)
 	long n,r;
 	char time_buffer[100];
 
+	free(malloc(4));
+
 	for(i = 0 ; i < argc ; i++)
 		printf("%2d) \"%s\"\n",i,argv[i]);