C / C++ / MFC

// Code modifed from  http://research.microsoft.com/en-us/um/redmond/projects/invisible/src/base/md/i386/sim/_glue.c.htm

typedef struct _KSYSTEM_TIME 
{
 UINT32 LowPart;
 INT32 High1Time;
 INT32 High2Time;
} KSYSTEM_TIME, *PKSYSTEM_TIME;

typedef struct _KUSER_SHARED_DATA 
{
 /* Current low 32-bit of tick count and tick count multiplier.
 * N.B. The tick count is updated each time the clock ticks.
 */
 volatile ULONG TickCountLow;
 UINT32 TickCountMultiplier;

 /* Current 64-bit interrupt time in 100ns units. */
 volatile KSYSTEM_TIME InterruptTime;

 /* Current 64-bit system time in 100ns units. */
 volatile KSYSTEM_TIME SystemTime;

 /* Current 64-bit time zone bias. */
 volatile KSYSTEM_TIME TimeZoneBias;
} KUSER_SHARED_DATA, *PKUSER_SHARED_DATA;

// NOTE the KUSER_SHARED_DATA structure has many extra fields which have been added over time.
// see http://uninformed.org/index.cgi?v=2&a=2&p=15
// So the declaration of the structure here is incomplete but is maximally backwards compatible.

#define MM_SHARED_USER_DATA_VA      0x7FFE0000
#define USER_SHARED_DATA ((KUSER_SHARED_DATA * const)MM_SHARED_USER_DATA_VA)


double dInterruptTimer(void)
{
 // returns the interrupt time in ms - time since the operating system was last started.
 // not including times in sleep or hibernation. I think this is probably the same
 // time as the time returned by KeQueryUnbiasedInterruptTime 
 // See http://msdn.microsoft.com/en-gb/library/windows/hardware/ff553077(v=vs.85).aspx
 union 
 {
  KSYSTEM_TIME SysTime;
  __int64 CurrTime;
 } ts;
 ts.SysTime.High1Time = USER_SHARED_DATA->InterruptTime.High1Time;
 ts.SysTime.LowPart   = USER_SHARED_DATA->InterruptTime.LowPart;
 return ts.CurrTime/(double)10000;
}

 // http://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/
 //  However, to ensure applications (Win32) to read a consistent time value, the order in which the members of KSYSTEM_TIME are updated has a very strict manner. 
// The ISR first updates High2Time, then LowPart, and finally High1Time. 
 // A consuming application must read the structure the same strict but 
 // inverse order, that is, it first reads High1Time, then LowPart, 
 // and finally High2Time. If High1Time and High2Time are equal, 
 // the High1Time:LowPart is a consistent value. 
 // Otherwise the application was interrupted by the clock interrupt and 
 // needs to read the structure again.

 for(;;)
 {
  ts.SysTime.High1Time = USER_SHARED_DATA->InterruptTime.High1Time;
  ts.SysTime.LowPart   = USER_SHARED_DATA->InterruptTime.LowPart;
  if(ts.SysTime.High1Time == USER_SHARED_DATA->InterruptTime.High2Time);
   break;
  ntests++;
 } 

static Spec_Thread double ddwt_was;
if(ddwt_was!=0)
if(ddwt<ddwt_was)
 ddwt=ddwt;
ddwt_was=ddwt;

ddwt    22589372.894629
ddwt_was    22589372.895075

{
  DWORD threadAffMask=SetThreadAffinityMask(GetCurrentThread(),1);
  QueryPerformanceCounter(&HPT_PerformanceCount);
  SetThreadAffinityMask(GetCurrentThread(),threadAffMask );
}

naseer861 wrote:

post comprehensive series in win32 API

Richard MacCutchan wrote:

I have had a similar issue in the past and used the
GetTextExtentPoint32() function. I also found it necessary to add
the size of a couple of extra characters as the calculation seems very precise.

Le@rner wrote:

rcText.right = min(rcText.right, sizeText.cx);

rcText.right = rcText.left + sizeText.cx

CRect rcLabel;
m_label.GetWindowRect(rcLabel); //get screen co-ordinate for static ctrl
rcLabel.right = rcLabel.left + sizeText.cx; //increase/decrease the rect width
ScreenToClient(rcLabel); // convert screen co-ordinate to client co-ordinate
m_label.MoveWindow(rcLabel); //move the static ctrl to new position