[frontierkernel-commits] Frontier/Common/source FastTimes.c,NONE,1.1 timedate.c,1.6,1.7 lang.c,1.5,1.6

[Seth D. <set...@us...>]

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

Modified Files:
	timedate.c lang.c 
Added Files:
	FastTimes.c 
Log Message:
Added clock.milliseconds() verb, and a getmilliseconds() function.
On the mac, getmilliseconds() is a macro, and it uses FastTimes.c (which is in the public domain). It is very fast, but the first call takes a long time. Not sure what to do about that, maybe it should be moved to startup?
Also, the script profiler now reports in milliseconds (1000ths) instead of in ticks (sixtieths).

Index: timedate.c
===================================================================
RCS file: /cvsroot/frontierkernel/Frontier/Common/source/timedate.c,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -d -r1.6 -r1.7
*** timedate.c	11 Jan 2005 22:48:11 -0000	1.6
--- timedate.c	13 Jan 2005 23:54:18 -0000	1.7
***************
*** 35,38 ****
--- 35,39 ----
  #include "langinternal.h"
  #include "shell.h"
+ 
  #include "timedate.h"
  
***************
*** 1536,1539 ****
--- 1537,1561 ----
  
  
+ #ifdef WIN95VERSION
+ 
+ static unsigned long long getlongermilliseconds (void) {
+ 	LARGE_INTEGER counter, freq;
+ 	unsigned long long freqLong;
+ 	
+ 	QueryPerformanceCounter (&counter);  /* counter hits since boot-up */
+ 	
+ 	QueryPerformanceFrequency (&freq);   /* frequency of coutner hits (per second) */
+ 	
+ 	freqLong = ( freq.LowPart | ( freq.HighPart << 32 ) ) / 1000;
+ 	
+ 	return ( counter.LowPart | ( counter.HighPart << 32 ) ) / freqLong;
+ } /* getlongermilliseconds */
+ 
+ 
+ extern long getmilliseconds(void) {
+ 	return ((long) getlongermilliseconds ());
+ } /* getmilliseconds */
+ 
+ #endif
  
  

Index: lang.c
===================================================================
RCS file: /cvsroot/frontierkernel/Frontier/Common/source/lang.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** lang.c	11 Jan 2005 22:48:05 -0000	1.5
--- lang.c	13 Jan 2005 23:54:18 -0000	1.6
***************
*** 47,50 ****
--- 47,55 ----
  #include "shell.rsrc.h"
  #include "shellhooks.h"
+ 
+ #ifdef WIN95VERSION
+ 	#include "timedate.h" /* for the milliseconds function */
+ #endif
+ 
  #include "process.h"
  #include "tablestructure.h"
***************
*** 145,149 ****
  	//short ix, ixtop;
  	tyerrorrecord *pe;
! 	unsigned long ticksnow = gettickcount ();
  	
  	if ((hs == nil) || ((**hs).toperror <= 0))
--- 150,155 ----
  	//short ix, ixtop;
  	tyerrorrecord *pe;
! 	/*unsigned long ticksnow = gettickcount ();*/
! 	unsigned long msnow = getmilliseconds ();
  	
  	if ((hs == nil) || ((**hs).toperror <= 0))
***************
*** 166,170 ****
  		pe = &(**hs).stack [(**hs).toperror - 1];
  		
! 		(*pe).profilebase = ticksnow;
  		
  		(*pe).profiletotal = 0;
--- 172,176 ----
  		pe = &(**hs).stack [(**hs).toperror - 1];
  		
! 		(*pe).profilebase = msnow;
  		
  		(*pe).profiletotal = 0;
***************
*** 185,189 ****
  	short ix;
  	tyerrorrecord item;
! 	unsigned long ticksnow = gettickcount ();
  	
  	if ((hs == nil) || ((**hs).toperror <= 0))
--- 191,196 ----
  	short ix;
  	tyerrorrecord item;
! 	/*unsigned long ticksnow = gettickcount ();*/
! 	unsigned long msnow = getmilliseconds ();
  	
  	if ((hs == nil) || ((**hs).toperror <= 0))
***************
*** 198,202 ****
  			if (item.profilebase != 0) { // included in profile
  			
! 				item.profiletotal += ticksnow - item.profilebase;
  				
  				langtracktimeslice (&item);
--- 205,209 ----
  			if (item.profilebase != 0) { // included in profile
  			
! 				item.profiletotal += msnow - item.profilebase;
  				
  				langtracktimeslice (&item);
***************
*** 236,240 ****
  	if (hp && (**hp).flprofiling) {
  		
! 		item.profilebase = gettickcount ();
  		
  		item.profiletotal = 0;
--- 243,248 ----
  	if (hp && (**hp).flprofiling) {
  		
! 		/* item.profilebase = gettickcount (); */
! 		item.profilebase = getmilliseconds ();
  		
  		item.profiletotal = 0;
***************
*** 280,284 ****
  		item = (**hs).stack [ixtop]; // the one we just popped
  		
! 		item.profiletotal += gettickcount () - item.profilebase;
  		
  		pe = &(**hs).stack [ixtop - 1]; // new new current top item
--- 288,293 ----
  		item = (**hs).stack [ixtop]; // the one we just popped
  		
! 		/* item.profiletotal += gettickcount () - item.profilebase; */
! 		item.profiletotal += getmilliseconds () - item.profilebase;
  		
  		pe = &(**hs).stack [ixtop - 1]; // new new current top item
***************
*** 288,292 ****
  		
  		if ((**hp).flprofilesliced && (ixtop > 0)) // restart previous function timer
! 			(*pe).profilebase = gettickcount ();
  		}
  	
--- 297,302 ----
  		
  		if ((**hp).flprofilesliced && (ixtop > 0)) // restart previous function timer
! 			/* (*pe).profilebase = gettickcount (); */
! 			(*pe).profilebase = getmilliseconds ();
  		}
  	

--- NEW FILE: FastTimes.c ---
/* File "FastTimes.c" - Original code by Matt Slot <fpr...@am...>  */
/* Created 4/24/99    - This file is hereby placed in the public domain       */
/* Updated 5/21/99    - Calibrate to VIA, add TBR support, renamed functions  */
/* Updated 10/4/99    - Use AbsoluteToNanoseconds() in case Absolute = double */
/* Updated 2/15/00    - Check for native Time Manager, no need to calibrate   */
/* Updated 2/19/00    - Fixed default value for gScale under native Time Mgr  */
/* Updated 3/21/00    - Fixed ns conversion, create 2 different scale factors */
/* Updated 5/03/00    - Added copyright and placed into PD. No code changes   */
/* Updated 8/01/00    - Made "Carbon-compatible" by replacing LMGetTicks()    */
/* Updated 8/22/00    - Fixed optimizer bug, changed GENPPC macros, extern C  */

/* This file is Copyright (C) Matt Slot, 1999-2000. It is hereby placed into 
   the public domain. The author makes no warranty as to fitness or stability */

#include <Gestalt.h>
#include <LowMem.h>
#include <CodeFragments.h>
#include <DriverServices.h>
#include <Timer.h>

#include "FastTimes.h"

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/*
	On 680x0 machines, we just use Microseconds().
	
	On PowerPC machines, we try several methods:
	  * DriverServicesLib is available on all PCI PowerMacs, and perhaps
	    some NuBus PowerMacs. If it is, we use UpTime() : Overhead = 2.1 µsec.
	  * The PowerPC 601 has a built-in "real time clock" RTC, and we fall
	    back to that, accessing it directly from asm. Overhead = 1.3 µsec.
	  * Later PowerPCs have an accurate "time base register" TBR, and we 
	    fall back to that, access it from PowerPC asm. Overhead = 1.3 µsec.
	  * We can also try Microseconds() which is emulated : Overhead = 36 µsec.

	On PowerPC machines, we avoid the following:
	  * OpenTransport is available on all PCI and some NuBus PowerMacs, but it
	    uses UpTime() if available and falls back to Microseconds() otherwise.
	  * InputSprocket is available on many PowerMacs, but again it uses
	    UpTime() if available and falls back to Microseconds() otherwise.

	Another PowerPC note: certain configurations, especially 3rd party upgrade
	cards, may return inaccurate timings for the CPU or memory bus -- causing
	skew in various system routines (up to 20% drift!). The VIA chip is very
	accurate, and it's the basis for the Time Manager and Microseconds().
	Unfortunately, it's also very slow because the MacOS has to (a) switch to
	68K and (b) poll for a VIA event.
	
	We compensate for the drift by calibrating a floating point scale factor
	between our fast method and the accurate timer at startup, then convert
	each sample quickly on the fly. I'd rather not have the initialization 
	overhead -- but it's simply necessary for accurate timing. You can drop
	it down to 30 ticks if you prefer, but that's as low as I'd recommend.

	Under MacOS 9, "new world" Macs (iMacs, B+W G3s and G+W G4s) have a native
	Time Manager implementation: UpTime(), Microseconds(), and TickCount() are
	all based on the same underlying counter. This makes it silly to calibrate
	UpTime() against TickCount(). We now check for this feature using Gestalt(),
	and skip the whole calibration step if possible.

*/
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

#define RTCToNano(w)	((double) (w).hi * 1000000000.0 + (double) (w).lo)
#define WideTo64bit(w)	(*(UInt64 *) &(w))

/* LMGetTicks() is not in Carbon and TickCount() has a fair bit of overhead,
   so for speed we always read lowmem directly. This is a MacOS X no-no, but 
   it always work on those systems that don't have a native Time Manager (ie,
   anything before MacOS 9) -- regardless whether we are in Carbon or not! */
#define MyLMGetTicks()	(*(volatile UInt32 *) 0x16A)

static Boolean			gInited = false;

#if TARGET_CPU_PPC

static Boolean			gNative = false;
static Boolean			gUseRTC = false;
static Boolean			gUseTBR = false;
static double			gScaleUSec = 1.0 / 1000.0;    /* 1 / ( nsec / usec) */
static double			gScaleMSec = 1.0 / 1000000.0; /* 1 / ( nsec / msec) */

static asm UnsignedWide PollRTC(void);
static asm UnsignedWide PollTBR(void);
static Ptr FindFunctionInSharedLib(StringPtr libName, StringPtr funcName);

/* Functions loaded from DriverServicesLib */
typedef AbsoluteTime 	(*UpTimeProcPtr)(void);
typedef Nanoseconds 	(*A2NSProcPtr)(AbsoluteTime);
static UpTimeProcPtr 	gUpTime = NULL;
static A2NSProcPtr 		gA2NS = NULL;

#endif /* TARGET_CPU_PPC */

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

void FastInitialize() {
	SInt32			result;

	if (!gInited) {

#if TARGET_CPU_PPC

		/* Initialize the feature flags */
		gNative = gUseRTC = gUseTBR = false;

		/* We use CFM to find and load needed symbols from shared libraries, so
		   the application doesn't have to weak-link them, for convenience.   */
		gUpTime = (UpTimeProcPtr) FindFunctionInSharedLib(
				"\pDriverServicesLib", "\pUpTime");
		if (gUpTime) gA2NS = (A2NSProcPtr) FindFunctionInSharedLib(
				"\pDriverServicesLib", "\pAbsoluteToNanoseconds");
		if (!gA2NS) gUpTime = nil; /* Pedantic but necessary */

		if (gUpTime) {
			/* If we loaded UpTime(), then we need to know if the system has
			   a native implementation of the Time Manager. If so, then it's
			   pointless to calculate a scale factor against the missing VIA */

			/* gestaltNativeTimeMgr = 4 in some future version of the headers */
			if (!Gestalt(gestaltTimeMgrVersion, &result) &&
					(result > gestaltExtendedTimeMgr)) 
				gNative = true;
			}
		  else {
			/* If no DriverServicesLib, use Gestalt() to get the processor type. 
			   Only NuBus PowerMacs with old System Software won't have DSL, so
			   we know it should either be a 601 or 603. */

			/* Use the processor gestalt to determine which register to use */
		 	if (!Gestalt(gestaltNativeCPUtype, &result)) {
				if (result == gestaltCPU601) gUseRTC = true;
				  else if (result > gestaltCPU601) gUseTBR = true;
				}
			}

		/* Now calculate a scale factor to keep us accurate. */
		if ((gUpTime && !gNative) || gUseRTC || gUseTBR) {
			UInt64			tick, usec1, usec2;
			UnsignedWide	wide;

			/* Wait for the beginning of the very next tick */
#if TARGET_API_MAC_CARBON
			for(tick = TickCount() + 1; tick > TickCount(); );
#else
			for(tick = MyLMGetTicks() + 1; tick > MyLMGetTicks(); );
#endif /* TARGET_API_MAC_CARBON */

			/* Poll the selected timer and prepare it (since we have time) */
			wide = (gUpTime) ? (*gA2NS)((*gUpTime)()) : 
					((gUseRTC) ? PollRTC() : PollTBR());
			usec1 = (gUseRTC) ? RTCToNano(wide) : WideTo64bit(wide);
			
			/* Wait for the exact 60th tick to roll over */
#if TARGET_API_MAC_CARBON
			while(tick + 60 > TickCount());
#else
			while(tick + 60 > MyLMGetTicks());
#endif /* TARGET_API_MAC_CARBON */

			/* Poll the selected timer again and prepare it  */
			wide = (gUpTime) ? (*gA2NS)((*gUpTime)()) : 
					((gUseRTC) ? PollRTC() : PollTBR());
			usec2 = (gUseRTC) ? RTCToNano(wide) : WideTo64bit(wide);
			
			/* Calculate a scale value that will give microseconds per second.
			   Remember, there are actually 60.15 ticks in a second, not 60.  */
			gScaleUSec = (60.0 * 1000000.0) / ((usec2 - usec1) * 60.15);
			gScaleMSec = gScaleUSec / 1000.0;
			}

#endif /* TARGET_CPU_PPC */

		/* We've initialized our globals */
		gInited = true;
		}
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

UInt64 FastMicroseconds() {
	UnsignedWide	wide;
	UInt64			usec;
	
#if TARGET_CPU_PPC
	/* Initialize globals the first time we are called */
	if (!gInited) FastInitialize();
	
	if (gNative) {
		/* Use DriverServices if it's available -- it's fast and compatible */
		wide = (*gA2NS)((*gUpTime)());
		usec = (double) WideTo64bit(wide) * gScaleUSec + 0.5;
		}
	  else if (gUpTime) {
		/* Use DriverServices if it's available -- it's fast and compatible */
		wide = (*gA2NS)((*gUpTime)());
		usec = (double) WideTo64bit(wide) * gScaleUSec + 0.5;
		}
	  else if (gUseTBR) {
		/* On a recent PowerPC, we poll the TBR directly */
		wide = PollTBR();
		usec = (double) WideTo64bit(wide) * gScaleUSec + 0.5;
		}
	  else if (gUseRTC) {
		/* On a 601, we can poll the RTC instead */
		wide = PollRTC();
		usec = (double) RTCToNano(wide) * gScaleUSec + 0.5;
		}
	  else 
#endif /* TARGET_CPU_PPC */
		{
		/* If all else fails, suffer the mixed mode overhead */
		Microseconds(&wide);
		usec = WideTo64bit(wide);
		}

	return(usec);
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

UInt64 FastMilliseconds() {
	UnsignedWide	wide;
	UInt64			msec;	
	
#if TARGET_CPU_PPC
	/* Initialize globals the first time we are called */
	if (!gInited) FastInitialize();
	
	if (gNative) {
		/* Use DriverServices if it's available -- it's fast and compatible */
		wide = (*gA2NS)((*gUpTime)());
		msec = (double) WideTo64bit(wide) * gScaleMSec + 0.5;
		}
	  else if (gUpTime) {
		/* Use DriverServices if it's available -- it's fast and compatible */
		wide = (*gA2NS)((*gUpTime)());
		msec = (double) WideTo64bit(wide) * gScaleMSec + 0.5;
		}
	  else if (gUseTBR) {
		/* On a recent PowerPC, we poll the TBR directly */
		wide = PollTBR();
		msec = (double) WideTo64bit(wide) * gScaleMSec + 0.5;
		}
	  else if (gUseRTC) {
		/* On a 601, we can poll the RTC instead */
		wide = PollRTC();
		msec = (double) RTCToNano(wide) * gScaleMSec + 0.5;
		}
	  else 
#endif /* TARGET_CPU_PPC */
		{
		/* If all else fails, suffer the mixed mode overhead */
		Microseconds(&wide);
		msec = ((double) WideTo64bit(wide) + 500.0) / 1000.0;
		}

	return(msec);
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

StringPtr FastMethod() {
	StringPtr	method = "\p<Unknown>";

#if TARGET_CPU_PPC
	/* Initialize globals the first time we are called */
	if (!gInited) FastInitialize();
	
	if (gNative) {
		/* The Time Manager and UpTime() are entirely native on this machine */
		method = "\pNative UpTime()";
		}
	  else if (gUpTime) {
		/* Use DriverServices if it's available -- it's fast and compatible */
		method = "\pUpTime()";
		}
	  else if (gUseTBR) {
		/* On a recent PowerPC, we poll the TBR directly */
		method = "\pPowerPC TBR";
		}
	  else if (gUseRTC) {
		/* On a 601, we can poll the RTC instead */
		method = "\pPowerPC RTC";
		}
	  else 
#endif /* TARGET_CPU_PPC */
		{
		/* If all else fails, suffer the mixed mode overhead */
		method = "\pMicroseconds()";
		}

	return(method);
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
#pragma mark -

#if TARGET_CPU_PPC
asm static UnsignedWide PollRTC_() {
entry PollRTC /* Avoid CodeWarrior glue */
	machine 601
@AGAIN:
	mfrtcu	r4 /* RTCU = SPR 4 */
	mfrtcl	r5 /* RTCL = SPR 5 */
	mfrtcu	r6
	cmpw	r4,r6
	bne		@AGAIN
	stw		r4,0(r3)
	stw		r5,4(r3)
	blr
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

asm static UnsignedWide PollTBR_() {
entry PollTBR /* Avoid CodeWarrior glue */
	machine 604
@AGAIN:
	mftbu	r4 /* TBRU = SPR 268 */
	mftb	r5 /* TBRL = SPR 269 */
	mftbu	r6
	cmpw	r4,r6
	bne		@AGAIN
	stw		r4,0(r3)
	stw		r5,4(r3)
	blr
	}

/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
/* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */

static Ptr FindFunctionInSharedLib(StringPtr libName, StringPtr funcName) {
	OSErr				error = noErr;
	Str255				errorStr;
	Ptr					func = NULL;
	Ptr					entry = NULL;
	CFragSymbolClass	symClass;
	CFragConnectionID	connID;
	
	/* Find CFM containers for the current archecture -- CFM-PPC or CFM-68K */
	if (/* error = */ GetSharedLibrary(libName, kCompiledCFragArch,
			kLoadCFrag, &connID, &entry, errorStr)) return(NULL);
	if (/* error = */ FindSymbol(connID, funcName, &func, &symClass))
		return(NULL);
	
	return(func);
	}
#endif /* TARGET_CPU_PPC */