ADDED   doc/timerate.n
Index: doc/timerate.n
==================================================================
--- /dev/null
+++ doc/timerate.n
@@ -0,0 +1,114 @@
+'\"
+'\" Copyright (c) 2005 Sergey Brester aka sebres.
+'\"
+'\" See the file "license.terms" for information on usage and redistribution
+'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+'\"
+.TH timerate n "" Tcl "Tcl Built-In Commands"
+.so man.macros
+.BS
+'\" Note:  do not modify the .SH NAME line immediately below!
+.SH NAME
+timerate \- Time-related execution resp. performance measurement of a script
+.SH SYNOPSIS
+\fBtimerate \fIscript\fR \fI?time?\fR
+.sp
+\fBtimerate \fI?-direct?\fR \fI?-overhead double?\fR \fIscript\fR \fI?time?\fR
+.sp
+\fBtimerate \fI?-calibrate?\fR \fI?-direct?\fR \fIscript\fR \fI?time?\fR
+.BE
+.SH DESCRIPTION
+.PP
+The first and second form will evaluate \fIscript\fR until the interval
+\fItime\fR given in milliseconds elapses, or for 1000 milliseconds (1 second)
+if \fItime\fR is not specified. 
+.sp
+It will then return a canonical tcl-list of the form
+.PP
+.CS
+\f0.095977 µs/# 52095836 # 10419167 #/sec 5000.000 nett-ms\fR
+.CE
+.PP
+which indicates:
+.IP \(bu
+the average amount of time required per iteration, in microseconds (lindex $result 0)
+.IP \(bu
+the count how many times it was executed (lindex $result 2)
+.IP \(bu
+the estimated rate per second (lindex $result 4)
+.IP \(bu
+the estimated real execution time without measurement overhead (lindex $result 6)
+.PP
+Time is measured in elapsed time using heighest timer resolution as possible, not CPU time.
+This command may be used to provide information as to how well the script or a tcl-command 
+is performing and can help determine bottlenecks and fine-tune application performance.
+.PP
+\fI-calibrate\fR
+.
+To measure very fast scripts as exact as posible the calibration process
+may be required.
+
+This parameter used to calibrate \fBtimerate\fR calculating the estimated overhead 
+of given \fIscript\fR as default overhead for further execution of \fBtimerate\fR.
+It can take up to 10 seconds if parameter \fItime\fR is not specified.
+.PP
+\fI-overhead double\fR
+.
+This parameter used to supply the measurement overhead of single iteration 
+(in microseconds) that should be ignored during whole evaluation process.
+.PP
+\fI-direct\fR
+.
+Causes direct execution per iteration (not compiled variant of evaluation used).
+.PP
+In opposition to \fBtime\fR the execution limited here by fixed time instead of 
+repetition count.
+Additionally the compiled variant of the script will be used during whole evaluation 
+(as if it were part of a compiled \fBproc\fR), if parameter \fI-direct\fR is not specified.
+Therefore it provides more precise results and prevents very long execution time 
+by slow scripts resp. scripts with unknown speed.
+
+.SH EXAMPLE
+Estimate how fast it takes for a simple Tcl \fBfor\fR loop (including
+operations on variable \fIi\fR) to count to a ten:
+.PP
+.CS
+# calibrate:
+timerate -calibrate {}
+# measure:
+timerate { for {set i 0} {$i<10} {incr i} {} } 5000
+.CE
+.PP
+Estimate how fast it takes for a simple Tcl \fBfor\fR loop only (ignoring the 
+overhead for operations on variable \fIi\fR) to count to a ten:
+.PP
+.CS
+# calibrate for overhead of variable operations:
+set i 0; timerate -calibrate {expr {$i<10}; incr i} 1000
+# measure:
+timerate { for {set i 0} {$i<10} {incr i} {} } 5000
+.CE
+.PP
+Estimate the rate of calculating the hour using \fBclock format\fR only, ignoring 
+overhead of the rest, without measurement how fast it takes for a whole script:
+.PP
+.CS
+# calibrate:
+timerate -calibrate {}
+# estimate overhead:
+set tm 0
+set ovh [lindex [timerate { incr tm [expr {24*60*60}] }] 0]
+# measure using esimated overhead:
+set tm 0
+timerate -overhead $ovh {
+    clock format $tm -format %H
+    incr tm [expr {24*60*60}]; # overhead for this is ignored
+} 5000
+.CE
+.SH "SEE ALSO"
+time(n)
+.SH KEYWORDS
+script, timerate, time
+.\" Local Variables:
+.\" mode: nroff
+.\" End:

Index: generic/tclBasic.c
==================================================================
--- generic/tclBasic.c
+++ generic/tclBasic.c
@@ -287,10 +287,13 @@
     {"seek",		Tcl_SeekObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
     {"socket",		Tcl_SocketObjCmd,	NULL,			NULL,	0},
     {"source",		Tcl_SourceObjCmd,	NULL,			TclNRSourceObjCmd,	0},
     {"tell",		Tcl_TellObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
     {"time",		Tcl_TimeObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
+#ifdef TCL_TIMERATE
+    {"timerate",	Tcl_TimeRateObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
+#endif
     {"unload",		Tcl_UnloadObjCmd,	NULL,			NULL,	0},
     {"update",		Tcl_UpdateObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {"vwait",		Tcl_VwaitObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
     {NULL,		NULL,			NULL,			NULL,	0}
 };
@@ -858,10 +861,14 @@
             TclNRAssembleObjCmd, NULL, NULL);
     cmdPtr->compileProc = &TclCompileAssembleCmd;
 
     Tcl_NRCreateCommand(interp, "::tcl::unsupported::inject", NULL,
 	    NRCoroInjectObjCmd, NULL, NULL);
+
+    /* Adding the timerate (unsupported) command */
+    Tcl_CreateObjCommand(interp, "::tcl::unsupported::timerate",
+        Tcl_TimeRateObjCmd, NULL, NULL);
 
 #ifdef USE_DTRACE
     /*
      * Register the tcl::dtrace command.
      */

Index: generic/tclCmdMZ.c
==================================================================
--- generic/tclCmdMZ.c
+++ generic/tclCmdMZ.c
@@ -15,10 +15,11 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  */
 
 #include "tclInt.h"
+#include "tclCompile.h"
 #include "tclRegexp.h"
 #include "tclStringTrim.h"
 
 static inline Tcl_Obj *	During(Tcl_Interp *interp, int resultCode,
 			    Tcl_Obj *oldOptions, Tcl_Obj *errorInfo);
@@ -4021,10 +4022,353 @@
     TclNewLiteralStringObj(objs[3], "iteration");
     Tcl_SetObjResult(interp, Tcl_NewListObj(4, objs));
 
     return TCL_OK;
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tcl_TimeRateObjCmd --
+ *
+ *	This object-based procedure is invoked to process the "timerate" Tcl
+ *	command.
+ *	This is similar to command "time", except the execution limited by
+ *	given time (in milliseconds) instead of repetition count.
+ *
+ * Example:
+ *	timerate {after 5} 1000 ; # equivalent for `time {after 5} [expr 1000/5]`
+ *
+ * Results:
+ *	A standard Tcl object result.
+ *
+ * Side effects:
+ *	See the user documentation.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tcl_TimeRateObjCmd(
+    ClientData dummy,		/* Not used. */
+    Tcl_Interp *interp,		/* Current interpreter. */
+    int objc,			/* Number of arguments. */
+    Tcl_Obj *const objv[])	/* Argument objects. */
+{
+    static double measureOverhead = 0; /* global measure-overhead */
+    double overhead = -1;	/* given measure-overhead */
+    register Tcl_Obj *objPtr;
+    register int result, i;
+    Tcl_Obj *calibrate = NULL, *direct = NULL;
+    Tcl_WideInt count = 0;	/* Holds repetition count */
+    Tcl_WideInt maxms = -0x7FFFFFFFFFFFFFFFL;
+				/* Maximal running time (in milliseconds) */
+    Tcl_WideInt threshold = 1;	/* Current threshold for check time (faster
+				 * repeat count without time check) */
+    Tcl_WideInt maxIterTm = 1;	/* Max time of some iteration as max threshold
+				 * additionally avoid divide to zero (never < 1) */
+    register Tcl_WideInt start, middle, stop;
+#ifndef TCL_WIDE_CLICKS
+    Tcl_Time now;
+#endif
+
+    static const char *const options[] = {
+	"-direct",	"-overhead",	"-calibrate",	"--",	NULL
+    };
+    enum options {
+	TMRT_EV_DIRECT,	TMRT_OVERHEAD,	TMRT_CALIBRATE,	TMRT_LAST
+    };
+
+    NRE_callback *rootPtr;
+    ByteCode	 *codePtr = NULL;
+
+    for (i = 1; i < objc - 1; i++) {
+    	int index;
+	if (Tcl_GetIndexFromObj(NULL, objv[i], options, "option", TCL_EXACT,
+		&index) != TCL_OK) {
+	    break;
+	}
+	if (index == TMRT_LAST) {
+	    i++;
+	    break;
+	}
+	switch (index) {
+	case TMRT_EV_DIRECT:
+	    direct = objv[i];
+	    break;
+	case TMRT_OVERHEAD:
+	    if (++i >= objc - 1) {
+		goto usage;
+	    }
+	    if (Tcl_GetDoubleFromObj(interp, objv[i], &overhead) != TCL_OK) {
+		return TCL_ERROR;
+	    }
+	    break;
+	case TMRT_CALIBRATE:
+	    calibrate = objv[i];
+	    break;
+	}
+    }
+
+    if (i >= objc || i < objc-2) {
+usage:
+	Tcl_WrongNumArgs(interp, 1, objv, "?-direct? ?-calibrate? ?-overhead double? command ?time?");
+	return TCL_ERROR;
+    }
+    objPtr = objv[i++];
+    if (i < objc) {
+	result = TclGetWideIntFromObj(interp, objv[i], &maxms);
+	if (result != TCL_OK) {
+	    return result;
+	}
+    }
+
+    /* if calibrate */
+    if (calibrate) {
+
+	/* if no time specified for the calibration */
+	if (maxms == -0x7FFFFFFFFFFFFFFFL) {
+	    Tcl_Obj *clobjv[6];
+	    Tcl_WideInt maxCalTime = 5000;
+	    double lastMeasureOverhead = measureOverhead;
+
+	    clobjv[0] = objv[0];
+	    i = 1;
+	    if (direct) {
+	    	clobjv[i++] = direct;
+	    }
+	    clobjv[i++] = objPtr;
+
+	    /* reset last measurement overhead */
+	    measureOverhead = (double)0;
+
+	    /* self-call with 100 milliseconds to warm-up,
+	     * before entering the calibration cycle */
+	    TclNewIntObj(clobjv[i], 100);
+	    Tcl_IncrRefCount(clobjv[i]);
+	    result = Tcl_TimeRateObjCmd(dummy, interp, i+1, clobjv);
+	    Tcl_DecrRefCount(clobjv[i]);
+	    if (result != TCL_OK) {
+		return result;
+	    }
+
+	    i--;
+	    clobjv[i++] = calibrate;
+	    clobjv[i++] = objPtr;
+
+	    /* set last measurement overhead to max */
+	    measureOverhead = (double)0x7FFFFFFFFFFFFFFFL;
+
+	    /* calibration cycle until it'll be preciser */
+	    maxms = -1000;
+	    do {
+		lastMeasureOverhead = measureOverhead;
+		TclNewIntObj(clobjv[i], (int)maxms);
+		Tcl_IncrRefCount(clobjv[i]);
+		result = Tcl_TimeRateObjCmd(dummy, interp, i+1, clobjv);
+		Tcl_DecrRefCount(clobjv[i]);
+		if (result != TCL_OK) {
+		    return result;
+		}
+		maxCalTime += maxms;
+		/* increase maxms for preciser calibration */
+		maxms -= (-maxms / 4);
+		/* as long as new value more as 0.05% better */
+	    } while ( (measureOverhead >= lastMeasureOverhead
+		    || measureOverhead / lastMeasureOverhead <= 0.9995)
+		    && maxCalTime > 0
+	    );
+
+	    return result;
+	}
+	if (maxms == 0) {
+	    /* reset last measurement overhead */
+	    measureOverhead = 0;
+	    Tcl_SetObjResult(interp, Tcl_NewLongObj(0));
+	    return TCL_OK;
+	}
+
+	/* if time is negative - make current overhead more precise */
+	if (maxms > 0) {
+	    /* set last measurement overhead to max */
+	    measureOverhead = (double)0x7FFFFFFFFFFFFFFFL;
+	} else {
+	    maxms = -maxms;
+	}
+
+    }
+
+    if (maxms == -0x7FFFFFFFFFFFFFFFL) {
+    	maxms = 1000;
+    }
+    if (overhead == -1) {
+	overhead = measureOverhead;
+    }
+
+    /* be sure that resetting of result will not smudge the further measurement */
+    Tcl_ResetResult(interp);
+
+    /* compile object */
+    if (!direct) {
+	if (TclInterpReady(interp) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	codePtr = TclCompileObj(interp, objPtr, NULL, 0);
+	TclPreserveByteCode(codePtr);
+    }
+
+    /* get start and stop time */
+#ifdef TCL_WIDE_CLICKS
+    start = middle = TclpGetWideClicks();
+    /* time to stop execution (in wide clicks) */
+    stop = start + (maxms * 1000 / TclpWideClickInMicrosec());
+#else
+    Tcl_GetTime(&now);
+    start = now.sec; start *= 1000000; start += now.usec;
+    middle = start;
+    /* time to stop execution (in microsecs) */
+    stop = start + maxms * 1000;
+#endif
+
+    /* start measurement */
+    while (1) {
+    	/* eval single iteration */
+    	count++;
+
+	if (!direct) {
+	    /* precompiled */
+	    rootPtr = TOP_CB(interp);
+	    result = TclNRExecuteByteCode(interp, codePtr);
+	    result = TclNRRunCallbacks(interp, result, rootPtr);
+	} else {
+	    /* eval */
+	    result = TclEvalObjEx(interp, objPtr, 0, NULL, 0);
+	}
+	if (result != TCL_OK) {
+	    goto done;
+	}
+
+	/* don't check time up to threshold */
+	if (--threshold > 0) continue;
+
+	/* check stop time reached, estimate new threshold */
+    #ifdef TCL_WIDE_CLICKS
+	middle = TclpGetWideClicks();
+    #else
+	Tcl_GetTime(&now);
+	middle = now.sec; middle *= 1000000; middle += now.usec;
+    #endif
+	if (middle >= stop) {
+	    break;
+	}
+
+	/* don't calculate threshold by few iterations, because sometimes
+	 * first iteration(s) can be too fast (cached, delayed clean up, etc) */
+	if (count < 10) {
+	   threshold = 1; continue;
+	}
+
+	/* average iteration time in microsecs */
+	threshold = (middle - start) / count;
+	if (threshold > maxIterTm) {
+	    maxIterTm = threshold;
+	}
+	/* as relation between remaining time and time since last check */
+	threshold = ((stop - middle) / maxIterTm) / 4;
+	if (threshold > 100000) {	    /* fix for too large threshold */
+	    threshold = 100000;
+	}
+    }
+
+    {
+	Tcl_Obj *objarr[8], **objs = objarr;
+	Tcl_WideInt val;
+	const char *fmt;
+
+	middle -= start;		     /* execution time in microsecs */
+
+    #ifdef TCL_WIDE_CLICKS
+	/* convert execution time in wide clicks to microsecs */
+	middle *= TclpWideClickInMicrosec();
+    #endif
+
+	/* if not calibrate */
+	if (!calibrate) {
+	    /* minimize influence of measurement overhead */
+	    if (overhead > 0) {
+		/* estimate the time of overhead (microsecs) */
+		Tcl_WideInt curOverhead = overhead * count;
+		if (middle > curOverhead) {
+		    middle -= curOverhead;
+		} else {
+		    middle = 1;
+		}
+	    }
+	} else {
+	    /* calibration - obtaining new measurement overhead */
+	    if (measureOverhead > (double)middle / count) {
+		measureOverhead = (double)middle / count;
+	    }
+	    objs[0] = Tcl_NewDoubleObj(measureOverhead);
+	    TclNewLiteralStringObj(objs[1], "\xC2\xB5s/#-overhead"); /* mics */
+	    objs += 2;
+	}
+
+	val = middle / count;		     /* microsecs per iteration */
+	if (val >= 1000000) {
+	    objs[0] = Tcl_NewWideIntObj(val);
+	} else {
+	    if (val < 10)    { fmt = "%.6f"; } else
+	    if (val < 100)   { fmt = "%.4f"; } else
+	    if (val < 1000)  { fmt = "%.3f"; } else
+	    if (val < 10000) { fmt = "%.2f"; } else
+			     { fmt = "%.1f"; };
+	    objs[0] = Tcl_ObjPrintf(fmt, ((double)middle)/count);
+	}
+
+	objs[2] = Tcl_NewWideIntObj(count); /* iterations */
+
+	/* calculate speed as rate (count) per sec */
+	if (!middle) middle++; /* +1 ms, just to avoid divide by zero */
+	if (count < (0x7FFFFFFFFFFFFFFFL / 1000000)) {
+	    val = (count * 1000000) / middle;
+	    if (val < 100000) {
+		if (val < 100)	{ fmt = "%.3f"; } else
+		if (val < 1000) { fmt = "%.2f"; } else
+				{ fmt = "%.1f"; };
+		objs[4] = Tcl_ObjPrintf(fmt, ((double)(count * 1000000)) / middle);
+	    } else {
+		objs[4] = Tcl_NewWideIntObj(val);
+	    }
+	} else {
+	    objs[4] = Tcl_NewWideIntObj((count / middle) * 1000000);
+	}
+
+	/* estimated net execution time (in millisecs) */
+	if (!calibrate) {
+	    objs[6] = Tcl_ObjPrintf("%.3f", (double)middle / 1000);
+	    TclNewLiteralStringObj(objs[7], "nett-ms");
+	}
+
+	/*
+	* Construct the result as a list because many programs have always parsed
+	* as such (extracting the first element, typically).
+	*/
+
+	TclNewLiteralStringObj(objs[1], "\xC2\xB5s/#"); /* mics/# */
+	TclNewLiteralStringObj(objs[3], "#");
+	TclNewLiteralStringObj(objs[5], "#/sec");
+	Tcl_SetObjResult(interp, Tcl_NewListObj(8, objarr));
+    }
+
+done:
+
+    if (codePtr) {
+	TclReleaseByteCode(codePtr);
+    }
+    return result;
+}
 
 /*
  *----------------------------------------------------------------------
  *
  * Tcl_TryObjCmd, TclNRTryObjCmd --

Index: generic/tclInt.h
==================================================================
--- generic/tclInt.h
+++ generic/tclInt.h
@@ -3248,14 +3248,26 @@
 			    Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
 #endif
 MODULE_SCOPE void	TclInitThreadStorage(void);
 MODULE_SCOPE void	TclFinalizeThreadDataThread(void);
 MODULE_SCOPE void	TclFinalizeThreadStorage(void);
+
 #ifdef TCL_WIDE_CLICKS
 MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
 MODULE_SCOPE double	TclpWideClicksToNanoseconds(Tcl_WideInt clicks);
+MODULE_SCOPE double	TclpWideClickInMicrosec(void);
+#else
+#   ifdef _WIN32
+#	define TCL_WIDE_CLICKS 1
+MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
+MODULE_SCOPE double	TclpWideClickInMicrosec(void);
+#	define		TclpWideClicksToNanoseconds(clicks) \
+				((double)(clicks) * TclpWideClickInMicrosec() * 1000)
+#   endif
 #endif
+MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
+
 MODULE_SCOPE int	TclZlibInit(Tcl_Interp *interp);
 MODULE_SCOPE void *	TclpThreadCreateKey(void);
 MODULE_SCOPE void	TclpThreadDeleteKey(void *keyPtr);
 MODULE_SCOPE void	TclpThreadSetMasterTSD(void *tsdKeyPtr, void *ptr);
 MODULE_SCOPE void *	TclpThreadGetMasterTSD(void *tsdKeyPtr);
@@ -3522,10 +3534,13 @@
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	Tcl_ThrowObjCmd(ClientData dummy, Tcl_Interp *interp,
 			    int objc, Tcl_Obj *const objv[]);
 MODULE_SCOPE int	Tcl_TimeObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
+			    Tcl_Obj *const objv[]);
+MODULE_SCOPE int	Tcl_TimeRateObjCmd(ClientData clientData,
+			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	Tcl_TraceObjCmd(ClientData clientData,
 			    Tcl_Interp *interp, int objc,
 			    Tcl_Obj *const objv[]);
 MODULE_SCOPE int	Tcl_TryObjCmd(ClientData clientData,

ADDED   tests-perf/clock.perf.tcl
Index: tests-perf/clock.perf.tcl
==================================================================
--- /dev/null
+++ tests-perf/clock.perf.tcl
@@ -0,0 +1,411 @@
+#!/usr/bin/tclsh
+# ------------------------------------------------------------------------
+#
+# test-performance.tcl --
+# 
+#  This file provides common performance tests for comparison of tcl-speed
+#  degradation by switching between branches.
+#  (currently for clock ensemble only)
+#
+# ------------------------------------------------------------------------
+# 
+# Copyright (c) 2014 Serg G. Brester (aka sebres)
+# 
+# See the file "license.terms" for information on usage and redistribution
+# of this file.
+# 
+
+array set in {-time 500}
+if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
+  array set in $argv
+}
+
+## common test performance framework:
+if {![namespace exists ::tclTestPerf]} {
+  source [file join [file dirname [info script]] test-performance.tcl]
+}
+
+namespace eval ::tclTestPerf-TclClock {
+
+namespace path {::tclTestPerf}
+
+## set testing defaults:
+set ::env(TCL_TZ) :CET
+
+# warm-up interpeter compiler env, clock platform-related features:
+
+## warm-up test-related features (load clock.tcl, system zones, locales, etc.):
+clock scan "" -gmt 1
+clock scan ""
+clock scan "" -timezone :CET
+clock scan "" -format "" -locale en
+clock scan "" -format "" -locale de
+
+## ------------------------------------------
+
+proc test-format {{reptime 1000}} {
+  _test_run $reptime {
+    # Format : short, week only (in gmt)
+    {clock format 1482525936 -format "%u" -gmt 1}
+    # Format : short, week only (system zone)
+    {clock format 1482525936 -format "%u"}
+    # Format : short, week only (CEST)
+    {clock format 1482525936 -format "%u" -timezone :CET}
+    # Format : date only (in gmt)
+    {clock format 1482525936 -format "%Y-%m-%d" -gmt 1}
+    # Format : date only (system zone)
+    {clock format 1482525936 -format "%Y-%m-%d"}
+    # Format : date only (CEST)
+    {clock format 1482525936 -format "%Y-%m-%d" -timezone :CET}
+    # Format : time only (in gmt)
+    {clock format 1482525936 -format "%H:%M" -gmt 1}
+    # Format : time only (system zone)
+    {clock format 1482525936 -format "%H:%M"}
+    # Format : time only (CEST)
+    {clock format 1482525936 -format "%H:%M" -timezone :CET}
+    # Format : time only (in gmt)
+    {clock format 1482525936 -format "%H:%M:%S" -gmt 1}
+    # Format : time only (system zone)
+    {clock format 1482525936 -format "%H:%M:%S"}
+    # Format : time only (CEST)
+    {clock format 1482525936 -format "%H:%M:%S" -timezone :CET}
+    # Format : default (in gmt)
+    {clock format 1482525936 -gmt 1 -locale en}
+    # Format : default (system zone)
+    {clock format 1482525936 -locale en}
+    # Format : default (CEST)
+    {clock format 1482525936 -timezone :CET -locale en}
+    # Format : ISO date-time (in gmt, numeric zone)
+    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z" -gmt 1}
+    # Format : ISO date-time (system zone, CEST, numeric zone)
+    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z"}
+    # Format : ISO date-time (CEST, numeric zone)
+    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z" -timezone :CET}
+    # Format : ISO date-time (system zone, CEST)
+    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %Z"}
+    # Format : julian day with time (in gmt):
+    {clock format 1246379415 -format "%J %H:%M:%S" -gmt 1}
+    # Format : julian day with time (system zone):
+    {clock format 1246379415 -format "%J %H:%M:%S"}
+
+    # Format : locale date-time (en):
+    {clock format 1246379415 -format "%x %X" -locale en}
+    # Format : locale date-time (de):
+    {clock format 1246379415 -format "%x %X" -locale de}
+
+    # Format : locale lookup table month:
+    {clock format 1246379400 -format "%b" -locale en -gmt 1}
+    # Format : locale lookup 2 tables - month and day:
+    {clock format 1246379400 -format "%b %Od" -locale en -gmt 1}
+    # Format : locale lookup 3 tables - week, month and day:
+    {clock format 1246379400 -format "%a %b %Od" -locale en -gmt 1}
+    # Format : locale lookup 4 tables - week, month, day and year:
+    {clock format 1246379400 -format "%a %b %Od %Oy" -locale en -gmt 1}
+
+    # Format : dynamic clock value (without converter caches):
+    setup {set i 0}
+    {clock format [incr i] -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET}
+    cleanup {puts [clock format $i -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET]}
+    # Format : dynamic clock value (without any converter caches, zone range overflow):
+    setup {set i 0}
+    {clock format [incr i 86400] -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET}
+    cleanup {puts [clock format $i -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET]}
+
+    # Format : dynamic format (cacheable)
+    {clock format 1246379415 -format [string trim "%d.%m.%Y %H:%M:%S "] -gmt 1}
+
+    # Format : all (in gmt, locale en)
+    {clock format 1482525936 -format "%%a = %a | %%A = %A | %%b = %b | %%h = %h | %%B = %B | %%C = %C | %%d = %d | %%e = %e | %%g = %g | %%G = %G | %%H = %H | %%I = %I | %%j = %j | %%J = %J | %%k = %k | %%l = %l | %%m = %m | %%M = %M | %%N = %N | %%p = %p | %%P = %P | %%Q = %Q | %%s = %s | %%S = %S | %%t = %t | %%u = %u | %%U = %U | %%V = %V | %%w = %w | %%W = %W | %%y = %y | %%Y = %Y | %%z = %z | %%Z = %Z | %%n = %n | %%EE = %EE | %%EC = %EC | %%Ey = %Ey | %%n = %n | %%Od = %Od | %%Oe = %Oe | %%OH = %OH | %%Ok = %Ok | %%OI = %OI | %%Ol = %Ol | %%Om = %Om | %%OM = %OM | %%OS = %OS | %%Ou = %Ou | %%Ow = %Ow | %%Oy = %Oy" -gmt 1 -locale en}
+    # Format : all (in CET, locale de)
+    {clock format 1482525936 -format "%%a = %a | %%A = %A | %%b = %b | %%h = %h | %%B = %B | %%C = %C | %%d = %d | %%e = %e | %%g = %g | %%G = %G | %%H = %H | %%I = %I | %%j = %j | %%J = %J | %%k = %k | %%l = %l | %%m = %m | %%M = %M | %%N = %N | %%p = %p | %%P = %P | %%Q = %Q | %%s = %s | %%S = %S | %%t = %t | %%u = %u | %%U = %U | %%V = %V | %%w = %w | %%W = %W | %%y = %y | %%Y = %Y | %%z = %z | %%Z = %Z | %%n = %n | %%EE = %EE | %%EC = %EC | %%Ey = %Ey | %%n = %n | %%Od = %Od | %%Oe = %Oe | %%OH = %OH | %%Ok = %Ok | %%OI = %OI | %%Ol = %Ol | %%Om = %Om | %%OM = %OM | %%OS = %OS | %%Ou = %Ou | %%Ow = %Ow | %%Oy = %Oy" -timezone :CET -locale de}
+  }
+}
+
+proc test-scan {{reptime 1000}} {
+  _test_run $reptime {
+    # Scan : date (in gmt)
+    {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0 -gmt 1}
+    # Scan : date (system time zone, with base)
+    {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0}
+    # Scan : date (system time zone, without base)
+    {clock scan "25.11.2015" -format "%d.%m.%Y"}
+    # Scan : greedy match
+    {clock scan "111" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "1111" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "11111" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "111111" -format "%d%m%y" -base 0 -gmt 1}
+    # Scan : greedy match (space separated)
+    {clock scan "1 1 1" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "111 1" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "1 111" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "1 11 1" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "1 11 11" -format "%d%m%y" -base 0 -gmt 1}
+    {clock scan "11 11 11" -format "%d%m%y" -base 0 -gmt 1}
+
+    # Scan : time (in gmt)
+    {clock scan "10:35:55" -format "%H:%M:%S" -base 1000000000 -gmt 1}
+    # Scan : time (system time zone, with base)
+    {clock scan "10:35:55" -format "%H:%M:%S" -base 1000000000}
+    # Scan : time (gmt, without base)
+    {clock scan "10:35:55" -format "%H:%M:%S" -gmt 1}
+    # Scan : time (system time zone, without base)
+    {clock scan "10:35:55" -format "%H:%M:%S"}
+
+    # Scan : date-time (in gmt)
+    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S" -base 0 -gmt 1}
+    # Scan : date-time (system time zone with base)
+    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S" -base 0}
+    # Scan : date-time (system time zone without base)
+    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S"}
+
+    # Scan : julian day in gmt
+    {clock scan 2451545 -format %J -gmt 1}
+    # Scan : julian day in system TZ
+    {clock scan 2451545 -format %J}
+    # Scan : julian day in other TZ
+    {clock scan 2451545 -format %J -timezone +0200}
+    # Scan : julian day with time:
+    {clock scan "2451545 10:20:30" -format "%J %H:%M:%S"}
+    # Scan : julian day with time (greedy match):
+    {clock scan "2451545 102030" -format "%J%H%M%S"}
+
+    # Scan : century, lookup table month
+    {clock scan {1970 Jan 2} -format {%C%y %b %d} -locale en -gmt 1}
+    # Scan : century, lookup table month and day (both entries are first)
+    {clock scan {1970 Jan 01} -format {%C%y %b %Od} -locale en -gmt 1}
+    # Scan : century, lookup table month and day (list scan: entries with position 12 / 31)
+    {clock scan {2016 Dec 31} -format {%C%y %b %Od} -locale en -gmt 1}
+
+    # Scan : ISO date-time (CEST)
+    {clock scan "2009-06-30T18:30:00+02:00" -format "%Y-%m-%dT%H:%M:%S%z"}
+    {clock scan "2009-06-30T18:30:00 CEST" -format "%Y-%m-%dT%H:%M:%S %z"}
+    # Scan : ISO date-time (UTC)
+    {clock scan "2009-06-30T18:30:00Z" -format "%Y-%m-%dT%H:%M:%S%z"}
+    {clock scan "2009-06-30T18:30:00 UTC" -format "%Y-%m-%dT%H:%M:%S %z"}
+
+    # Scan : locale date-time (en):
+    {clock scan "06/30/2009 18:30:15" -format "%x %X" -gmt 1 -locale en}
+    # Scan : locale date-time (de):
+    {clock scan "30.06.2009 18:30:15" -format "%x %X" -gmt 1 -locale de}
+
+    # Scan : dynamic format (cacheable)
+    {clock scan "25.11.2015 10:35:55" -format [string trim "%d.%m.%Y %H:%M:%S "] -base 0 -gmt 1}
+
+    break
+    # # Scan : long format test (allock chain)
+    # {clock scan "25.11.2015" -format "%d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y" -base 0 -gmt 1}
+    # # Scan : dynamic, very long format test (create obj representation, allock chain, GC, etc):
+    # {clock scan "25.11.2015" -format [string repeat "[incr i] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
+    # # Scan : again:
+    # {clock scan "25.11.2015" -format [string repeat "[incr i -1] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
+  } {puts [clock format $_(r) -locale en]}
+}
+
+proc test-freescan {{reptime 1000}} {
+  _test_run $reptime {
+    # FreeScan : relative date
+    {clock scan "5 years 18 months 385 days" -base 0 -gmt 1}
+    # FreeScan : relative date with relative weekday
+    {clock scan "5 years 18 months 385 days Fri" -base 0 -gmt 1}
+    # FreeScan : relative date with ordinal month
+    {clock scan "5 years 18 months 385 days next 1 January" -base 0 -gmt 1}
+    # FreeScan : relative date with ordinal month and relative weekday
+    {clock scan "5 years 18 months 385 days next January Fri" -base 0 -gmt 1}
+    # FreeScan : ordinal month
+    {clock scan "next January" -base 0 -gmt 1}
+    # FreeScan : relative week
+    {clock scan "next Fri" -base 0 -gmt 1}
+    # FreeScan : relative weekday and week offset 
+    {clock scan "next January + 2 week" -base 0 -gmt 1}
+    # FreeScan : time only with base
+    {clock scan "19:18:30" -base 148863600 -gmt 1}
+    # FreeScan : time only without base, gmt
+    {clock scan "19:18:30" -gmt 1}
+    # FreeScan : time only without base, system
+    {clock scan "19:18:30"}
+    # FreeScan : date, system time zone
+    {clock scan "05/08/2016 20:18:30"}
+    # FreeScan : date, supplied time zone
+    {clock scan "05/08/2016 20:18:30" -timezone :CET}
+    # FreeScan : date, supplied gmt (equivalent -timezone :GMT)
+    {clock scan "05/08/2016 20:18:30" -gmt 1}
+    # FreeScan : date, supplied time zone gmt
+    {clock scan "05/08/2016 20:18:30" -timezone :GMT}
+    # FreeScan : time only, numeric zone in string, base time gmt (exchange zones between gmt / -0500)
+    {clock scan "20:18:30 -0500" -base 148863600 -gmt 1}
+    # FreeScan : time only, zone in string (exchange zones between system / gmt)
+    {clock scan "19:18:30 GMT" -base 148863600}
+    # FreeScan : fast switch of zones in cycle - GMT, MST, CET (system) and EST
+    {clock scan "19:18:30 MST" -base 148863600 -gmt 1
+     clock scan "19:18:30 EST" -base 148863600
+    }
+  } {puts [clock format $_(r) -locale en]}
+}
+
+proc test-add {{reptime 1000}} {
+  set tests {
+    # Add : years
+    {clock add 1246379415 5 years -gmt 1}
+    # Add : months
+    {clock add 1246379415 18 months -gmt 1}
+    # Add : weeks
+    {clock add 1246379415 20 weeks -gmt 1}
+    # Add : days
+    {clock add 1246379415 385 days -gmt 1}
+    # Add : weekdays
+    {clock add 1246379415 3 weekdays -gmt 1}
+
+    # Add : hours
+    {clock add 1246379415 5 hours -gmt 1}
+    # Add : minutes
+    {clock add 1246379415 55 minutes -gmt 1}
+    # Add : seconds
+    {clock add 1246379415 100 seconds -gmt 1}
+
+    # Add : +/- in gmt
+    {clock add 1246379415 -5 years +21 months -20 weeks +386 days -19 hours +30 minutes -10 seconds -gmt 1}
+    # Add : +/- in system timezone
+    {clock add 1246379415 -5 years +21 months -20 weeks +386 days -19 hours +30 minutes -10 seconds -timezone :CET}
+
+    # Add : gmt
+    {clock add 1246379415 -5 years 18 months 366 days 5 hours 30 minutes 10 seconds -gmt 1}
+    # Add : system timezone
+    {clock add 1246379415 -5 years 18 months 366 days 5 hours 30 minutes 10 seconds -timezone :CET}
+
+    # Add : all in gmt
+    {clock add 1246379415 4 years 18 months 50 weeks 378 days 3 weekdays 5 hours 30 minutes 10 seconds -gmt 1}
+    # Add : all in system timezone
+    {clock add 1246379415 4 years 18 months 50 weeks 378 days 3 weekdays 5 hours 30 minutes 10 seconds -timezone :CET}
+
+  }
+  # if does not support add of weekdays:
+  if {[catch {clock add 0 3 weekdays -gmt 1}]} {
+    regsub -all {\mweekdays\M} $tests "days" tests
+  }
+  _test_run $reptime $tests {puts [clock format $_(r) -locale en]}
+}
+
+proc test-convert {{reptime 1000}} {
+  _test_run $reptime {
+    # Convert locale (en -> de):
+    {clock format [clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en] -format "%a %b %d %Y" -gmt 1 -locale de}
+    # Convert locale (de -> en):
+    {clock format [clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de] -format "%a %b %d %Y" -gmt 1 -locale en}
+
+    # Convert TZ: direct
+    {clock format [clock scan "19:18:30" -base 148863600 -timezone EST] -timezone MST}
+    {clock format [clock scan "19:18:30" -base 148863600 -timezone MST] -timezone EST}
+    # Convert TZ: included in scan string & format
+    {clock format [clock scan "19:18:30 EST" -base 148863600] -format "%H:%M:%S %z" -timezone MST}
+    {clock format [clock scan "19:18:30 EST" -base 148863600] -format "%H:%M:%S %z" -timezone EST}
+
+    # Format locale 1x: comparison values
+    {clock format 0 -gmt 1 -locale en} 
+    {clock format 0 -gmt 1 -locale de}
+    {clock format 0 -gmt 1 -locale fr}
+    # Format locale 2x: without switching locale (en, en)
+    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en}
+    # Format locale 2x: with switching locale (en, de)
+    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale de}
+    # Format locale 3x: without switching locale (en, en, en)
+    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en}
+    # Format locale 3x: with switching locale (en, de, fr)
+    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale de; clock format 0 -gmt 1 -locale fr}
+
+    # Scan locale 2x: without switching locale (en, en) + (de, de)
+    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en}
+    {clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de}
+    # Scan locale 2x: with switching locale (en, de)
+    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de}
+    # Scan locale 3x: with switching locale (en, de, fr)
+    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de; clock scan "mar. mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale fr}
+
+    # Format TZ 2x: comparison values
+    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"}
+    {clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
+    # Format TZ 2x: without switching
+    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"}
+    {clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
+    # Format TZ 2x: with switching
+    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
+    # Format TZ 3x: with switching (CET, EST, MST)
+    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone MST -format "%Y-%m-%d %H:%M:%S %z"}
+    # Format TZ 3x: with switching (GMT, EST, MST)
+    {clock format 0 -gmt 1 -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone MST -format "%Y-%m-%d %H:%M:%S %z"}
+
+    # FreeScan TZ 2x (+1 system-default): without switching TZ
+    {clock scan "19:18:30 MST" -base 148863600; clock scan "19:18:30 MST" -base 148863600}
+    {clock scan "19:18:30 EST" -base 148863600; clock scan "19:18:30 EST" -base 148863600}
+    # FreeScan TZ 2x (+1 system-default): with switching TZ
+    {clock scan "19:18:30 MST" -base 148863600; clock scan "19:18:30 EST" -base 148863600}
+    # FreeScan TZ 2x (+1 gmt, +1 system-default)
+    {clock scan "19:18:30 MST" -base 148863600 -gmt 1; clock scan "19:18:30 EST" -base 148863600}
+    
+    # Scan TZ: comparison included in scan string vs. given
+    {clock scan "2009-06-30T18:30:00 CEST" -format "%Y-%m-%dT%H:%M:%S %z"}
+    {clock scan "2009-06-30T18:30:00 CET" -format "%Y-%m-%dT%H:%M:%S %z"}
+    {clock scan "2009-06-30T18:30:00" -timezone CET -format "%Y-%m-%dT%H:%M:%S"}
+  }
+}
+
+proc test-other {{reptime 1000}} {
+  _test_run $reptime {
+    # Bad zone
+    {catch {clock scan "1 day" -timezone BAD_ZONE -locale en}}
+
+    # Scan : julian day (overflow)
+    {catch {clock scan 5373485 -format %J}}
+
+    # Scan : test rotate of GC objects (format is dynamic, so tcl-obj removed with last reference)
+    {set i 0; time { clock scan "[incr i] - 25.11.2015" -format "$i - %d.%m.%Y" -base 0 -gmt 1 } 50}
+    # Scan : test reusability of GC objects (format is dynamic, so tcl-obj removed with last reference)
+    {set i 50; time { clock scan "[incr i -1] - 25.11.2015" -format "$i - %d.%m.%Y" -base 0 -gmt 1 } 50}
+  }
+}
+
+proc test-ensemble-perf {{reptime 1000}} {
+  _test_run $reptime {
+    # Clock clicks (ensemble)
+    {clock clicks}
+    # Clock clicks (direct)
+    {::tcl::clock::clicks}
+    # Clock seconds (ensemble)
+    {clock seconds}
+    # Clock seconds (direct)
+    {::tcl::clock::seconds}
+    # Clock microseconds (ensemble)
+    {clock microseconds}
+    # Clock microseconds (direct)
+    {::tcl::clock::microseconds}
+    # Clock scan (ensemble)
+    {clock scan ""}
+    # Clock scan (direct)
+    {::tcl::clock::scan ""}
+    # Clock format (ensemble)
+    {clock format 0 -f %s}
+    # Clock format (direct)
+    {::tcl::clock::format 0 -f %s}
+  }
+}
+
+proc test {{reptime 1000}} {
+  puts ""
+  test-ensemble-perf [expr {$reptime / 2}]; #fast enough
+  test-format $reptime
+  test-scan $reptime
+  test-freescan $reptime
+  test-add $reptime
+  test-convert [expr {$reptime / 2}]; #fast enough
+  test-other $reptime
+
+  puts \n**OK**
+}
+
+}; # end of ::tclTestPerf-TclClock
+
+# ------------------------------------------------------------------------
+
+# if calling direct:
+if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
+  ::tclTestPerf-TclClock::test $in(-time)
+}

ADDED   tests-perf/test-performance.tcl
Index: tests-perf/test-performance.tcl
==================================================================
--- /dev/null
+++ tests-perf/test-performance.tcl
@@ -0,0 +1,121 @@
+# ------------------------------------------------------------------------
+#
+# test-performance.tcl --
+# 
+#  This file provides common performance tests for comparison of tcl-speed
+#  degradation or regression by switching between branches.
+#
+#  To execute test case evaluate direct corresponding file "tests-perf\*.perf.tcl".
+#
+# ------------------------------------------------------------------------
+# 
+# Copyright (c) 2014 Serg G. Brester (aka sebres)
+# 
+# See the file "license.terms" for information on usage and redistribution
+# of this file.
+# 
+
+namespace eval ::tclTestPerf {
+# warm-up interpeter compiler env, calibrate timerate measurement functionality:
+
+# if no timerate here - import from unsupported:
+if {[namespace which -command timerate] eq {}} {
+  namespace inscope ::tcl::unsupported {namespace export timerate}
+  namespace import ::tcl::unsupported::timerate
+}
+
+# if not yet calibrated:
+if {[lindex [timerate {} 10] 6] >= (10-1)} {
+  puts -nonewline "Calibration ... "; flush stdout
+  puts "done: [lrange \
+    [timerate -calibrate {}] \
+  0 1]"
+}
+
+proc {**STOP**} {args} {
+  return -code error -level 4 "**STOP** in [info level [expr {[info level]-2}]] [join $args { }]" 
+}
+
+proc _test_get_commands {lst} {
+  regsub -all {(?:^|\n)[ \t]*(\#[^\n]*|\msetup\M[^\n]*|\mcleanup\M[^\n]*)(?=\n\s*(?:[\{\#]|setup|cleanup|$))} $lst "\n{\\1}"
+}
+
+proc _test_out_total {} {
+  upvar _ _
+
+  set tcnt [llength $_(itm)]
+  if {!$tcnt} {
+    puts ""
+    return
+  }
+
+  set mintm 0x7fffffff
+  set maxtm 0
+  set nett 0
+  set wtm 0
+  set wcnt 0
+  set i 0
+  foreach tm $_(itm) {
+    if {[llength $tm] > 6} {
+      set nett [expr {$nett + [lindex $tm 6]}]
+    }
+    set wtm [expr {$wtm + [lindex $tm 0]}]
+    set wcnt [expr {$wcnt + [lindex $tm 2]}]
+    set tm [lindex $tm 0]
+    if {$tm > $maxtm} {set maxtm $tm; set maxi $i}
+    if {$tm < $mintm} {set mintm $tm; set mini $i}
+    incr i
+  }
+
+  puts [string repeat ** 40]
+  set s [format "%d cases in %.2f sec." $tcnt [expr {([clock milliseconds] - $_(starttime)) / 1000.0}]]
+  if {$nett > 0} {
+    append s [format " (%.2f nett-sec.)" [expr {$nett / 1000.0}]]
+  }
+  puts "Total $s:"
+  lset _(m) 0 [format %.6f $wtm]
+  lset _(m) 2 $wcnt
+  lset _(m) 4 [format %.3f [expr {$wcnt / (($nett ? $nett : ($tcnt * $_(reptime))) / 1000.0)}]]
+  if {[llength $_(m)] > 6} {
+    lset _(m) 6 [format %.3f $nett]
+  }
+  puts $_(m)
+  puts "Average:"
+  lset _(m) 0 [format %.6f [expr {[lindex $_(m) 0] / $tcnt}]]
+  lset _(m) 2 [expr {[lindex $_(m) 2] / $tcnt}]
+  if {[llength $_(m)] > 6} {
+    lset _(m) 6 [format %.3f [expr {[lindex $_(m) 6] / $tcnt}]]
+    lset _(m) 4 [format %.0f [expr {[lindex $_(m) 2] / [lindex $_(m) 6] * 1000}]]
+  }
+  puts $_(m)
+  puts "Min:"
+  puts [lindex $_(itm) $mini]
+  puts "Max:"
+  puts [lindex $_(itm) $maxi]
+  puts [string repeat ** 40]
+  puts ""
+}
+
+proc _test_run {reptime lst {outcmd {puts $_(r)}}} {
+  upvar _ _
+  array set _ [list itm {} reptime $reptime starttime [clock milliseconds]]
+
+  foreach _(c) [_test_get_commands $lst] {
+    puts "% [regsub -all {\n[ \t]*} $_(c) {; }]"
+    if {[regexp {^\s*\#} $_(c)]} continue
+    if {[regexp {^\s*(?:setup|cleanup)\s+} $_(c)]} {
+      puts [if 1 [lindex $_(c) 1]]
+      continue
+    }
+    if {$reptime > 1} {; #if not once:
+      set _(r) [if 1 $_(c)]
+      if {$outcmd ne {}} $outcmd
+    }
+    puts [set _(m) [timerate $_(c) $reptime]]
+    lappend _(itm) $_(m)
+    puts ""
+  }
+  _test_out_total
+}
+
+}; # end of namespace ::tclTestPerf

Index: unix/tclUnixTime.c
==================================================================
--- unix/tclUnixTime.c
+++ unix/tclUnixTime.c
@@ -85,10 +85,36 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
+ * TclpGetMicroseconds --
+ *
+ *	This procedure returns the number of microseconds from the epoch.
+ *	On most Unix systems the epoch is Midnight Jan 1, 1970 GMT.
+ *
+ * Results:
+ *	Number of microseconds from the epoch.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_WideInt
+TclpGetMicroseconds(void)
+{
+    Tcl_Time time;
+
+    tclGetTimeProcPtr(&time, tclTimeClientData);
+    return ((Tcl_WideInt)time.sec)*1000000 + time.usec;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
  * TclpGetClicks --
  *
  *	This procedure returns a value that represents the highest resolution
  *	clock available on the system. There are no garantees on what the
  *	resolution will be. In Tcl we will call this value a "click". The
@@ -217,10 +243,55 @@
 #endif
     }
 
     return nsec;
 }
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpWideClickInMicrosec --
+ *
+ *	This procedure return scale to convert click values from the
+ *	TclpGetWideClicks native resolution to microsecond resolution
+ *	and back.
+ *
+ * Results:
+ * 	1 click in microseconds as double.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+double
+TclpWideClickInMicrosec(void)
+{
+    if (tclGetTimeProcPtr != NativeGetTime) {
+	return 1.0;
+    } else {
+#ifdef MAC_OSX_TCL
+	static int initialized = 0;
+	static double scale = 0.0;
+
+	if (initialized) {
+	    return scale;
+	} else {
+	    mach_timebase_info_data_t tb;
+
+	    mach_timebase_info(&tb);
+	    /* value of tb.numer / tb.denom = 1 click in nanoseconds */
+	    scale = ((double)tb.numer) / tb.denom / 1000;
+	    initialized = 1;
+	    return scale;
+	}
+#else
+#error Wide high-resolution clicks not implemented on this platform
+#endif
+    }
+}
 #endif /* TCL_WIDE_CLICKS */
 
 /*
  *----------------------------------------------------------------------
  *

Index: win/tclWinTime.c
==================================================================
--- win/tclWinTime.c
+++ win/tclWinTime.c
@@ -108,10 +108,21 @@
 #endif
     { 0 },
     { 0 },
     0
 };
+
+/*
+ * Scale to convert wide click values from the TclpGetWideClicks native
+ * resolution to microsecond resolution and back.
+ */
+static struct {
+    int initialized;		/* 1 if initialized, 0 otherwise */
+    int perfCounter;		/* 1 if performance counter usable for wide clicks */
+    double microsecsScale;	/* Denominator scale between clock / microsecs */
+} wideClick = {0, 0.0};
+
 
 /*
  * Declarations for functions defined later in this file.
  */
 
@@ -125,10 +136,11 @@
 			    Tcl_WideInt perfCounter, Tcl_WideInt perfFreq);
 static Tcl_WideInt	AccumulateSample(Tcl_WideInt perfCounter,
 			    Tcl_WideUInt fileTime);
 static void		NativeScaleTime(Tcl_Time* timebuf,
 			    ClientData clientData);
+static Tcl_WideInt	NativeGetMicroseconds(void);
 static void		NativeGetTime(Tcl_Time* timebuf,
 			    ClientData clientData);
 
 /*
  * TIP #233 (Virtualized Time): Data for the time hooks, if any.
@@ -156,14 +168,23 @@
  */
 
 unsigned long
 TclpGetSeconds(void)
 {
-    Tcl_Time t;
+    Tcl_WideInt usecSincePosixEpoch;
 
-    tclGetTimeProcPtr(&t, tclTimeClientData);	/* Tcl_GetTime inlined. */
-    return t.sec;
+    /* Try to use high resolution timer */
+    if ( tclGetTimeProcPtr == NativeGetTime
+      && (usecSincePosixEpoch = NativeGetMicroseconds())
+    ) {
+	return usecSincePosixEpoch / 1000000;
+    } else {
+	Tcl_Time t;
+
+	tclGetTimeProcPtr(&t, tclTimeClientData);	/* Tcl_GetTime inlined. */
+	return t.sec;
+    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -184,23 +205,151 @@
  */
 
 unsigned long
 TclpGetClicks(void)
 {
-    /*
-     * Use the Tcl_GetTime abstraction to get the time in microseconds, as
-     * nearly as we can, and return it.
-     */
-
-    Tcl_Time now;		/* Current Tcl time */
-    unsigned long retval;	/* Value to return */
-
-    tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
-
-    retval = (now.sec * 1000000) + now.usec;
-    return retval;
-
+    Tcl_WideInt usecSincePosixEpoch;
+
+    /* Try to use high resolution timer */
+    if ( tclGetTimeProcPtr == NativeGetTime
+      && (usecSincePosixEpoch = NativeGetMicroseconds())
+    ) {
+	return (unsigned long)usecSincePosixEpoch;
+    } else {
+	/*
+	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
+	* nearly as we can, and return it.
+	*/
+
+	Tcl_Time now;		/* Current Tcl time */
+
+	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
+	return (unsigned long)(now.sec * 1000000) + now.usec;
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGetWideClicks --
+ *
+ *	This procedure returns a WideInt value that represents the highest
+ *	resolution clock in microseconds available on the system.
+ *
+ * Results:
+ *	Number of microseconds (from some start time).
+ *
+ * Side effects:
+ *	This should be used for time-delta resp. for measurement purposes
+ *	only, because on some platforms can return microseconds from some
+ *	start time (not from the epoch).
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_WideInt
+TclpGetWideClicks(void)
+{
+    LARGE_INTEGER curCounter;
+
+    if (!wideClick.initialized) {
+	LARGE_INTEGER perfCounterFreq;
+
+	/*
+	 * The frequency of the performance counter is fixed at system boot and
+	 * is consistent across all processors. Therefore, the frequency need
+	 * only be queried upon application initialization.
+	 */
+	if (QueryPerformanceFrequency(&perfCounterFreq)) {
+	    wideClick.perfCounter = 1;
+	    wideClick.microsecsScale = 1000000.0 / perfCounterFreq.QuadPart;
+	} else {
+	    /* fallback using microseconds */
+	    wideClick.perfCounter = 0;
+	    wideClick.microsecsScale = 1;
+	}
+
+	wideClick.initialized = 1;
+    }
+    if (wideClick.perfCounter) {
+	if (QueryPerformanceCounter(&curCounter)) {
+	    return (Tcl_WideInt)curCounter.QuadPart;
+	}
+	/* fallback using microseconds */
+	wideClick.perfCounter = 0;
+	wideClick.microsecsScale = 1;
+	return TclpGetMicroseconds();
+    } else {
+    	return TclpGetMicroseconds();
+    }
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpWideClickInMicrosec --
+ *
+ *	This procedure return scale to convert wide click values from the
+ *	TclpGetWideClicks native resolution to microsecond resolution
+ *	and back.
+ *
+ * Results:
+ * 	1 click in microseconds as double.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+double
+TclpWideClickInMicrosec(void)
+{
+    if (!wideClick.initialized) {
+    	(void)TclpGetWideClicks();	/* initialize */
+    }
+    return wideClick.microsecsScale;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * TclpGetMicroseconds --
+ *
+ *	This procedure returns a WideInt value that represents the highest
+ *	resolution clock in microseconds available on the system.
+ *
+ * Results:
+ *	Number of microseconds (from the epoch).
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+Tcl_WideInt
+TclpGetMicroseconds(void)
+{
+    Tcl_WideInt usecSincePosixEpoch;
+
+    /* Try to use high resolution timer */
+    if ( tclGetTimeProcPtr == NativeGetTime
+      && (usecSincePosixEpoch = NativeGetMicroseconds())
+    ) {
+	return usecSincePosixEpoch;
+    } else {
+	/*
+	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
+	* nearly as we can, and return it.
+	*/
+
+	Tcl_Time now;
+
+	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
+	return (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
+    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -225,11 +374,21 @@
 
 void
 Tcl_GetTime(
     Tcl_Time *timePtr)		/* Location to store time information. */
 {
-    tclGetTimeProcPtr(timePtr, tclTimeClientData);
+    Tcl_WideInt usecSincePosixEpoch;
+
+    /* Try to use high resolution timer */
+    if ( tclGetTimeProcPtr == NativeGetTime
+      && (usecSincePosixEpoch = NativeGetMicroseconds())
+    ) {
+	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
+	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
+    } else {
+    	tclGetTimeProcPtr(timePtr, tclTimeClientData);
+    }
 }
 
 /*
  *----------------------------------------------------------------------
  *
@@ -258,17 +417,18 @@
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * NativeGetTime --
+ * NativeGetMicroseconds --
  *
- *	TIP #233: Gets the current system time in seconds and microseconds
- *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.
+ *	Gets the current system time in microseconds since the beginning
+ *	of the epoch: 00:00 UCT, January 1, 1970.
  *
  * Results:
- *	Returns the current time in timePtr.
+ *	Returns the wide integer with number of microseconds from the epoch, or
+ *	0 if high resolution timer is not available.
  *
  * Side effects:
  *	On the first call, initializes a set of static variables to keep track
  *	of the base value of the performance counter, the corresponding wall
  *	clock (obtained through ftime) and the frequency of the performance
@@ -277,17 +437,16 @@
  *	drift in the performance counter's oscillator.
  *
  *----------------------------------------------------------------------
  */
 
-static void
-NativeGetTime(
-    Tcl_Time *timePtr,
-    ClientData clientData)
+static Tcl_WideInt
+NativeGetMicroseconds(void)
 {
-    struct _timeb t;
-
+    static LARGE_INTEGER posixEpoch;
+				/* Posix epoch expressed as 100-ns ticks since
+				 * the windows epoch. */
     /*
      * Initialize static storage on the first trip through.
      *
      * Note: Outer check for 'initialized' is a performance win since it
      * avoids an extra mutex lock in the common case.
@@ -294,10 +453,14 @@
      */
 
     if (!timeInfo.initialized) {
 	TclpInitLock();
 	if (!timeInfo.initialized) {
+
+	    posixEpoch.LowPart = 0xD53E8000;
+	    posixEpoch.HighPart = 0x019DB1DE;
+
 	    timeInfo.perfCounterAvailable =
 		    QueryPerformanceFrequency(&timeInfo.nominalFreq);
 
 	    /*
 	     * Some hardware abstraction layers use the CPU clock in place of
@@ -406,19 +569,13 @@
 
 	LARGE_INTEGER curCounter;
 				/* Current performance counter. */
 	Tcl_WideInt curFileTime;/* Current estimated time, expressed as 100-ns
 				 * ticks since the Windows epoch. */
-	static LARGE_INTEGER posixEpoch;
-				/* Posix epoch expressed as 100-ns ticks since
-				 * the windows epoch. */
 	Tcl_WideInt usecSincePosixEpoch;
 				/* Current microseconds since Posix epoch. */
 
-	posixEpoch.LowPart = 0xD53E8000;
-	posixEpoch.HighPart = 0x019DB1DE;
-
 	QueryPerformanceCounter(&curCounter);
 
 	/*
 	 * Hold time section locked as short as possible
 	 */
@@ -434,13 +591,11 @@
 	 * If calibration cycle occurred after we get curCounter
 	 */
 	if (curCounter.QuadPart <= perfCounterLastCall.QuadPart) {
 	    usecSincePosixEpoch =
 		(fileTimeLastCall.QuadPart - posixEpoch.QuadPart) / 10;
-	    timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
-	    timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
-	    return;
+	    return usecSincePosixEpoch;
 	}
 
 	/*
 	 * If it appears to be more than 1.1 seconds since the last trip
 	 * through the calibration loop, the performance counter may have
@@ -457,23 +612,61 @@
 	    curFileTime = fileTimeLastCall.QuadPart +
 		 ((curCounter.QuadPart - perfCounterLastCall.QuadPart)
 		    * 10000000 / curCounterFreq.QuadPart);
 
 	    usecSincePosixEpoch = (curFileTime - posixEpoch.QuadPart) / 10;
-	    timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
-	    timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
-	    return;
+	    return usecSincePosixEpoch;
 	}
     }
 
     /*
-     * High resolution timer is not available. Just use ftime.
+     * High resolution timer is not available.
+     */
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * NativeGetTime --
+ *
+ *	TIP #233: Gets the current system time in seconds and microseconds
+ *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.
+ *
+ * Results:
+ *	Returns the current time in timePtr.
+ *
+ * Side effects:
+ *	See NativeGetMicroseconds for more information.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static void
+NativeGetTime(
+    Tcl_Time *timePtr,
+    ClientData clientData)
+{
+    Tcl_WideInt usecSincePosixEpoch;
+
+    /*
+     * Try to use high resolution timer.
      */
+    if ( (usecSincePosixEpoch = NativeGetMicroseconds()) ) {
+	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
+	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
+    } else {
+	/*
+	* High resolution timer is not available. Just use ftime.
+	*/
 
-    _ftime(&t);
-    timePtr->sec = (long)t.time;
-    timePtr->usec = t.millitm * 1000;
+	struct _timeb t;
+
+	_ftime(&t);
+	timePtr->sec = (long)t.time;
+	timePtr->usec = t.millitm * 1000;
+    }
 }
 
 /*
  *----------------------------------------------------------------------
  *