X-Git-Url: http://www.lcore.org/git/lcore.git/blobdiff_plain/36ee947888d0a2a0d0f47d3f89f035a5dc96931f..b60a32da0a15deb572474b1f66a6c63695ed7491:/btime.pas?ds=sidebyside

diff --git a/btime.pas b/btime.pas
index ee7583b..ae6ffa5 100644
--- a/btime.pas
+++ b/btime.pas
@@ -9,16 +9,22 @@ works on windows/delphi, and on freepascal on unix.
 
 
 unit btime;
+{$ifdef fpc}
+  {$mode delphi}
+{$endif}
+
+{$include lcoreconfig.inc}
 
 interface
 
-{$ifdef win32}
+{$ifdef mswindows}
 uses
   ltimevalstuff;
 {$endif}  
 
 type
   float=extended;
+  tunixtimeint={$ifdef ver100}longint;{$else}int64;{$endif}
 
 const
   colorburst=39375000/11;  {3579545.4545....}
@@ -26,41 +32,58 @@ const
 var
   timezone:integer;
   timezonestr:string;
-  irctime,unixtime:integer;
+  irctime,unixtime:tunixtimeint;
   tickcount:integer;
-  settimebias:integer;
+  settimebias:tunixtimeint;
   performancecountfreq:extended;
+  btimenowin8:boolean;
 
 function irctimefloat:float;
-function irctimeint:integer;
+function irctimeint:tunixtimeint;
 
+//unix timestamp (UTC) float seconds
 function unixtimefloat:float;
-function unixtimeint:integer;
+function unixtimeint:tunixtimeint;
+
+//monotonic float seconds
+function monotimefloat:float;
 
+//monotonic (alias, old function name)
 function wintimefloat:float;
 
-procedure settime(newtime:integer);
+procedure settime(newtime:tunixtimeint);
 procedure gettimezone;
 procedure timehandler;
 procedure init;
 
-function timestring(i:integer):string;
-function timestrshort(i:integer):string;
+function timestring(i:tunixtimeint):string;      // Wednesday August 15 2012 -- 16:21:09 +02:00
+function timestrshort(i:tunixtimeint):string;    // Wed Aug 15 16:21:09 2012
+function timestriso(i:tunixtimeint):string;      // 2012-08-15 16:21:09
+function timestrisoutc(i:float):string;          // 2012-08-15T14:21:09.255553Z
+
+procedure beginhightimerrate;
+procedure endhightimerrate;
+
+procedure tzinvalidate;
+
+{$ifdef unix}
+function tzgetoffsetforts(ts:tunixtimeint):integer;
+{$endif}
 
-{$ifdef win32}
+{$ifdef mswindows}
 function unixtimefloat_systemtime:float;
 {$endif}
 
 function oletounixfloat(t:float):float;
-function oletounix(t:tdatetime):integer;
+function oletounix(t:tdatetime):tunixtimeint;
 function unixtoole(i:float):tdatetime;
 
-{$ifdef win32}
+{$ifdef mswindows}
 function mmtimefloat:float;
 function qpctimefloat:float;
 {$endif}
 
-{$ifdef win32}
+{$ifdef mswindows}
 procedure gettimeofday(var tv:ttimeval);
 {$endif}
 
@@ -97,15 +120,15 @@ var
 
 implementation
 
-{$ifdef fpc}
-  {$mode delphi}
-{$endif}
+
 
 uses
   {$ifdef UNIX}
     {$ifdef VER1_0}
       linux,
     {$else}
+      {$ifdef linux}linux,{$endif} //for clock_gettime
+      {$ifdef freebsd}freebsd,{$endif} //for clock_gettime
       baseunix,unix,unixutil,sockets, {unixutil and sockets needed by unixstuff.inc on some compiler versions}
     {$endif}
   {$else}
@@ -125,9 +148,9 @@ begin
   result := t;
 end;
 
-function oletounix(t:tdatetime):integer;
+function oletounix(t:tdatetime):tunixtimeint;
 begin
-  result := trunc(oletounixfloat(t));
+  result := round(oletounixfloat(t));
 end;
 
 function unixtoole(i:float):tdatetime;
@@ -158,28 +181,102 @@ end;
 function unixtimefloat:float;
 var
   tv:ttimeval;
+  sec:tunixtimeint;
 begin
   gettimeofday(tv);
-  result := tv.tv_sec+(tv.tv_usec/1000000);
+  sec := tv.tv_sec;
+  {$ifndef cpu64}
+  if (sec < -1) then inc(sec,$100000000); //tv_sec is 32 bits. allow -1 for invalid result
+  {$endif}
+  result := sec+(tv.tv_usec/1000000);
 end;
 
-function wintimefloat:extended;
-begin
-  result := unixtimefloat;
-end;
+{$ifdef linux}{$define have_clock_gettime}{$endif}
+{$ifdef freebsd}{$define have_clock_gettime}{$endif}
+
+{$ifdef have_clock_gettime}
+  {$define monotimefloat_implemented}
+
+  function monotimefloat:float;
+  var
+    ts: ttimespec;
+  begin
+    if clock_gettime(CLOCK_MONOTONIC, @ts) = 0 then begin
+      //note this really returns nanoseconds
+      result := ts.tv_sec + ts.tv_nsec / 1000000000.0;
+      exit;
+    end;
+    //fallback
+    result := unixtimefloat;
+  end;
+
 
-function unixtimeint:integer;
+{$endif}
+
+{$ifdef darwin} {mac OS X}
+{$define monotimefloat_implemented}
+
+  type
+    tmach_timebase_info = packed record
+      numer: longint;
+      denom: longint;
+    end;
+    pmach_timebase_info = ^tmach_timebase_info;
+     
+    function mach_absolute_time: int64; cdecl; external;
+    function mach_timebase_info(info: pmach_timebase_info): integer; cdecl; external;
+
+  var
+    timebase_info: tmach_timebase_info;
+
+  function monotimefloat:float;
+  var
+    i:int64;
+  begin
+    if timebase_info.denom = 0 then begin
+      mach_timebase_info(@timebase_info);
+    end;
+    i := mach_absolute_time;
+    result := (i * timebase_info.numer div timebase_info.denom) / 1000000000.0;
+  end;
+
+{$endif} {darwin, mac OS X}
+
+
+{$ifndef monotimefloat_implemented} {fallback}
+  
+  function monotimefloat:extended;
+  begin
+    result := unixtimefloat;
+  end;
+
+{$endif} {monotimefloat fallback}
+
+
+function unixtimeint:tunixtimeint;
 var
   tv:ttimeval;
+  sec:tunixtimeint;
 begin
   gettimeofday(tv);
-  result := tv.tv_sec;
+  sec := tv.tv_sec;
+  {$ifndef cpu64}
+  if (sec < -1) then inc(sec,$100000000); //tv_sec is 32 bits. allow -1 for invalid result
+  {$endif}
+  result := sec;
 end;
 
-{$else} {delphi 3}
+{------------------------------ end of *nix/freepascal section}
+
+{$else} {windows}
 {------------------------------ windows/delphi code to read time}
 
 
+procedure tzinvalidate;
+begin
+  gettimezone;
+end;
+
 {simulate gettimeofday on windows so one can always use gettimeofday if preferred}
 
 procedure gettimeofday(var tv:ttimeval);
@@ -210,6 +307,7 @@ const
   wrapduration=highdwordconst * 0.001;
 var
   i:integer;
+  temp:float;
 begin
   i := gettickcount; {timegettime}
   if i < mmtime_last then begin
@@ -218,7 +316,17 @@ begin
   mmtime_last := i;
   result := mmtime_wrapadd + i * 0.001;
 
-  if (ticks_freq <> 0) and ticks_freq_known then result := int((result / ticks_freq)+0.5) * ticks_freq; //turn the float into an exact multiple of 1/64th sec to improve accuracy of things using this
+  if (ticks_freq <> 0) and ticks_freq_known then begin
+    {the value we get is rounded to 1 ms, but the ticks are not a multiple of 1 ms
+    this makes the value noisy. use the known ticks frequency to restore the original value}
+    temp := int((result / ticks_freq)+0.5) * ticks_freq;
+
+    {if the known ticks freq is wrong (can happen), disable the un-rounding behavior
+    this will be a bit less accurate but it prevents problems}
+    if abs(temp - result) > 0.002 then begin
+      ticks_freq := 0;
+    end else result := temp;
+  end;
 end;
 
 procedure measure_ticks_freq;
@@ -227,6 +335,8 @@ var
   o:tosversioninfo;
   isnt:boolean;
 {  is9x:boolean;}
+  adjust1,adjust2:cardinal;
+  adjustbool:longbool;
 begin
   if (performancecountfreq = 0) then qpctimefloat;
   ticks_freq_known := false;
@@ -243,39 +353,19 @@ begin
 
   ticks_freq2 := f;
   mmtime_synchedqpc := false;
-  {
-  NT 64 Hz
-  identify mode as: nt64
-  QPC rate: either 3579545 or TSC freq
-  QPC synched to gettickcount: no
-  duration between 2 ticks is constant: yes
-  gettickcount tick duration: 64 Hz
-  }
-  if (f >= 0.014) and (f <= 0.018) and isnt then begin
-    ticks_freq_known := true;
-    ticks_freq := 1/64;
-    mmtime_synchedqpc := false;
-  end;
 
-  {
-  NT 100 Hz
-  identify mode as: nt100
-  QPC rate: 1193182
-  QPC synched to gettickcount: yes
-  duration between 2 ticks is constant: no?
-  gettickcount tick duration: ~99.85 Hz
-  }
-  if (performancecountfreq = 1193182) and (f >= 0.008) and (f <= 0.012) and isnt then begin
-    ticks_freq_known := true;
-    ticks_freq2 := 11949 / (colorburst / 3);
-   //  ticks_freq2 := 11949 / 1193182;
-    ticks_freq := 0;
-    {the ticks freq should be very close to the real one but if it's not exact, it will cause drift and correction jumps}
-    mmtime_synchedqpc := true;
+  if (isnt and (o.dwMajorVersion >= 5)) then begin
+    {windows 2000 and later: query tick rate from OS in 100 ns units
+    typical rates: XP: 156250 or 100144, windows 7: 156001}
+    if GetSystemTimeAdjustment(adjust1,adjust2,adjustbool) then begin
+      ticks_freq := adjust1 / 10000000.0;
+      ticks_freq_known := true;
+      mmtime_synchedqpc := false;
+    end;
   end;
 
   {9x}
-  if (performancecountfreq = 1193182) and (g >= 0.050) and (g <= 0.060) then begin
+  if (performancecountfreq = 1193182) and (f >= 0.050) and (f <= 0.060) then begin
     ticks_freq_known := true;
     ticks_freq := 65536 / (colorburst / 3);
     mmtime_synchedqpc := true;
@@ -414,7 +504,7 @@ begin
   mmtime_lastresult := result;
 end;
 
-{ free pascals tsystemtime is incomaptible with windows api calls
+{ free pascals tsystemtime is incompatible with windows api calls
  so we declare it ourselves - plugwash
 }
 {$ifdef fpc}
@@ -468,24 +558,65 @@ begin
   result := oletounixfloat(int(date_utc+0.5))+time_utc*86400;
 end;
 
-function wintimefloat:extended;
+function monotimefloat:extended;
 begin
   result := mmqpctimefloat;
 end;
 
+
+
+var
+  GetSystemTimePreciseAsFileTime:procedure(var v:tfiletime); stdcall;
+  win8inited:boolean;
+
+procedure initwin8;
+var
+  dllhandle:thandle;
+
+begin
+  win8inited := true;
+  dllhandle := loadlibrary('kernel32.dll');
+  if (dllhandle <> 0) then begin
+    GetSystemTimePreciseAsFileTime := getprocaddress(dllhandle,'GetSystemTimePreciseAsFileTime');
+  end;
+end;
+
+
+function unixtimefloat_win8:float;
+var
+  ft:tfiletime;
+  i:int64 absolute ft;
+begin
+  GetSystemTimePreciseAsFileTime(ft);
+  {change from windows 1601-01-01 to unix 1970-01-01.
+  use integer math for this, to preserve precision}
+  dec(i, 116444736000000000);
+  result := (i / 10000000);
+end;
+
+
+
 function unixtimefloat:float;
 const
   margin = 0.0012;
 var
   f,g,h:float;
 begin
-  result := wintimefloat+timefloatbias;
+  if not btimenowin8 then begin
+    if not win8inited then initwin8;
+    if assigned(@GetSystemTimePreciseAsFileTime) then begin
+      result := unixtimefloat_win8;
+      exit;
+    end;  
+  end;
+
+  result := monotimefloat+timefloatbias;
   f := result-unixtimefloat_systemtime;
   if ((f > ticks_freq2+margin) or (f < -margin)) or (timefloatbias = 0) then begin
 //    writeln('unixtimefloat init');
     f := unixtimefloat_systemtime;
     settc;
-    repeat g := unixtimefloat_systemtime; h := wintimefloat until g > f;
+    repeat g := unixtimefloat_systemtime; h := monotimefloat until g > f;
     unsettc;
     timefloatbias := g-h;
     result := unixtimefloat;
@@ -496,7 +627,7 @@ begin
   lastunixtimefloat := result;
 end;
 
-function unixtimeint:integer;
+function unixtimeint:tunixtimeint;
 begin
   result := trunc(unixtimefloat);
 end;
@@ -504,20 +635,25 @@ end;
 {$endif}
 {-----------------------------------------------end of platform specific}
 
+function wintimefloat:float;
+begin
+  result := monotimefloat;
+end;
+
 function irctimefloat:float;
 begin
   result := unixtimefloat+settimebias;
 end;
 
-function irctimeint:integer;
+function irctimeint:tunixtimeint;
 begin
   result := unixtimeint+settimebias;
 end;
 
 
-procedure settime(newtime:integer);
+procedure settime(newtime:tunixtimeint);
 var
-  a:integer;
+  a:tunixtimeint;
 begin
   a := irctimeint-settimebias;
   if newtime = 0 then settimebias := 0 else settimebias := newtime-a;
@@ -540,6 +676,226 @@ begin
 end;
 
 
+{$ifdef unix}
+
+var
+  tzerror:boolean;
+  tzfile:ansistring;
+
+function tzgetfilename:ansistring;
+var
+  t:textfile;
+
+  s,tz,tzdir:ansistring;
+begin
+  result := '';
+  filemode := 0;
+  {$ifdef unix}
+  tz := getenv('TZ');
+
+  if (copy(tz,1,1) = ':') then begin
+    tz := copy(tz,2,99999);
+
+    if (copy(tz,1,1) <> '/') then begin
+      tzdir := getenv('TZDIR');
+      if (tzdir = '') then begin
+        tzdir := '/usr/share/zoneinfo/';
+      end else begin
+        if (copy(tzdir,length(tzdir),1) <> '/') then tzdir := tzdir + '/';
+      end;
+      tz := tzdir + tz;
+    end;
+
+    assignfile(t,tz);
+    {$i-}reset(t);{$i+}
+    if (ioresult = 0) then begin
+      closefile(t);
+      result := tz;
+      exit;
+    end;
+
+  end;
+  {$endif}
+  
+  assignfile(t,'/etc/localtime');
+  {$i-}reset(t);{$i+}
+  if (ioresult = 0) then begin
+    closefile(t);
+    result := '/etc/localtime';
+    exit;
+  end;
+
+  assignfile(t,'/etc/timezone');
+
+  s := '';
+  {$i-}reset(t);{$i+}
+  if (ioresult = 0) then begin
+    readln(t,s);
+    closefile(t);
+    if (s <> '') then begin
+      result := '/usr/share/zoneinfo/'+s;
+      exit;
+    end;
+  end;
+end;
+
+type
+  dvar=array[0..65535] of byte;
+  pdvar=^dvar;
+
+var
+  tzcache:pdvar;
+  tzsize:integer;
+
+procedure tzinvalidate;
+begin
+  if assigned(tzcache) then freemem(tzcache);
+  tzcache := nil;
+  tzsize := 0;
+  tzfile := '';
+  gettimezone;
+end;
+
+
+function tzgetoffsetforts(ts:tunixtimeint):integer;
+var
+  f:file;
+  buf:pdvar;
+  fs:integer;
+  ofs,ofs2:integer;
+  mode64:boolean;
+  has64:boolean;
+  a,index:integer;
+  //tzstrofs:integer;
+  t:int64;
+  tzh_ttisgmtcnt:integer;
+  tzh_ttisstdcnt:integer;
+  tzh_leapcnt:integer;
+  tzh_timecnt:integer;
+  tzh_typecnt:integer;
+  tzh_charcnt:integer;
+
+
+function getint:integer;
+begin
+  if (ofs < 0) or ((ofs + 4) > fs) then raise exception.create('getint');
+  result := (buf[ofs] shl 24) + (buf[ofs+1] shl 16) + (buf[ofs+2] shl 8) + buf[ofs+3];
+  inc(ofs,4);
+end;
+
+function getint64:int64;
+begin
+  if (ofs < 0) or ((ofs + 8) > fs) then raise exception.create('getint64');
+  result := int64(getint) shl 32;
+  inc(result,cardinal(getint));
+end;
+
+
+function getbyte:byte;
+begin
+  if (ofs < 0) or ((ofs + 1) > fs) then raise exception.create('getbyte');
+  result := buf[ofs];
+  inc(ofs);
+end;
+
+begin
+  result := 0;
+  tzerror := true;
+
+  if not assigned(tzcache) then begin
+
+    if (tzfile = '') then tzfile := tzgetfilename;
+
+    if (tzfile = '') then exit;
+
+    assignfile(f,tzfile);
+    filemode := 0;
+    {$i-}reset(f,1);{$i+}
+    if (ioresult <> 0) then begin
+      exit;
+    end;
+    tzsize := filesize(f);
+    if (tzsize > 65536) then tzsize := 65536;
+    getmem(tzcache,tzsize);
+    blockread(f,tzcache^,tzsize);
+    closefile(f);
+  end;
+  fs := tzsize;
+  buf := tzcache;
+  ofs := 0;
+  mode64 := false;
+
+ try
+   repeat
+     if (getint <> $545a6966) then exit; // 'TZif'
+     has64 := getbyte >= $32; //  '2'
+
+     inc(ofs,15);
+
+     tzh_ttisgmtcnt := getint;
+     tzh_ttisstdcnt := getint;
+     tzh_leapcnt := getint;
+     tzh_timecnt := getint;
+     tzh_typecnt := getint;
+     tzh_charcnt := getint;
+
+     if mode64 or (not has64) then break;
+     inc(ofs, 5 * tzh_timecnt + 6 * tzh_typecnt + 8 * tzh_leapcnt + tzh_ttisstdcnt + tzh_ttisgmtcnt + tzh_charcnt);
+     mode64 := true;
+   until false;
+   index := 0;
+
+   if (tzh_timecnt < 0) or (tzh_timecnt > fs) then raise exception.create('tzh_timecnt');
+   ofs2 := ofs;
+
+   for a := 0 to tzh_timecnt -1 do begin
+     if mode64 then t := getint64 else t := getint;
+     if (t > ts) then begin
+       index := a - 1;
+       break;
+     end;
+     if (a = tzh_timecnt -1) and (ts >= t) then index := a;
+   end;
+   ofs := ofs2 + tzh_timecnt * (1 + ord(mode64)) * 4;
+
+   if (cardinal(ofs + index) >= fs) or (index < 0) then raise exception.create('index');
+   index := buf[ofs+index];
+   inc(ofs,tzh_timecnt);
+
+   if (index >= tzh_typecnt) then raise exception.create('type');
+   ofs2 := ofs;
+  // writeln('ofs2 ',inttohex(ofs2,8));
+   inc(ofs,6 * index);
+   result := getint;
+
+   //tzisdst := getbyte;
+
+  //the abbreviation string
+  { tzstrofs := getbyte;
+   tzstr := '';
+   ofs := ofs2 + 6 * tzh_typecnt;
+   inc(ofs, tzstrofs);
+
+   repeat
+     a := getbyte;
+     if (a <> 0) then tzstr := tzstr + chr(a);
+   until (a = 0); }
+
+   tzerror := false;
+ except
+
+ end;
+end;
+
+function tzgetoffset:integer;
+begin
+  tzgetoffsetforts(unixtimeint);
+end;
+
+
+{$endif}
+
+
 procedure gettimezone;
 var
   {$ifdef UNIX}
@@ -556,7 +912,8 @@ var
 begin
   {$ifdef UNIX}
     {$ifdef above194}
-      timezone := tzseconds;
+      timezone := tzgetoffset;
+      //freepascal tzseconds is not 2038 safe
     {$else}
       gettime(hh,mm,ss);
       timezone := (longint(hh) * 3600 + mm * 60 + ss) - (unixtimeint mod 86400);
@@ -565,15 +922,15 @@ begin
   timezone := round((now-now_utc)*86400);
   {$endif}
 
-  while timezone > 43200 do dec(timezone,86400);
-  while timezone < -43200 do inc(timezone,86400);
+  while timezone > 50400 do dec(timezone,86400);
+  while timezone < -50400 do inc(timezone,86400);
 
   if timezone >= 0 then timezonestr := '+' else timezonestr := '-';
   l := abs(timezone) div 60;
   timezonestr := timezonestr + char(l div 600 mod 10+48)+char(l div 60 mod 10+48)+':'+char(l div 10 mod 6+48)+char(l mod 10+48);
 end;
 
-function timestrshort(i:integer):string;
+function timestrshort(i:tunixtimeint):string;
 const
   weekday:array[0..6] of string[4]=('Thu','Fri','Sat','Sun','Mon','Tue','Wed');
   month:array[0..11] of string[4]=('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
@@ -589,7 +946,7 @@ begin
   inttostr(y);
 end;
 
-function timestring(i:integer):string;
+function timestring(i:tunixtimeint):string;
 const
   weekday:array[0..6] of string[10]=('Thursday','Friday','Saturday','Sunday','Monday','Tuesday','Wednesday');
   month:array[0..11] of string[10]=('January','February','March','April','May','June','July','August','September','October','November','December');
@@ -605,9 +962,52 @@ begin
   timezonestr;
 end;
 
+function timestriso(i:tunixtimeint):string;
+var
+  y,m,d,h,min,sec,ms:word;
+  t:tdatetime;
+begin
+  t := unixtoole(i+timezone);
+  decodedate(t,y,m,d);
+  decodetime(t,h,min,sec,ms);
+  result := inttostr(y)+'-'+inttostr(m div 10)+inttostr(m mod 10)+'-'+inttostr(d div 10)+inttostr(d mod 10)+' '+inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10);
+end;
+
+function timestrisoutc(i:float):string;
+var
+  y,m,d,h,min,sec,ms:word;
+  t:tdatetime;
+  fr:float;
+begin
+  t := unixtoole(i);
+  decodedate(t,y,m,d);
+  decodetime(t,h,min,sec,ms);
+  result := inttostr(y)+'-'+inttostr(m div 10)+inttostr(m mod 10)+'-'+inttostr(d div 10)+inttostr(d mod 10)+'T'+inttostr(h div 10)+inttostr(h mod 10)+':'+inttostr(min div 10)+inttostr(min mod 10)+':'+inttostr(sec div 10)+inttostr(sec mod 10);
+  fr := frac(i);
+
+  result := result + '.'+
+  inttostr(trunc(fr*10) mod 10)+
+  inttostr(trunc(fr*100) mod 10)+
+  inttostr(trunc(fr*1000) mod 10)+
+  inttostr(trunc(fr*10000) mod 10)+
+  inttostr(trunc(fr*100000) mod 10)+
+  inttostr(trunc(fr*1000000) mod 10)+'Z';
+
+end;
+
+procedure beginhightimerrate;
+begin
+  {$ifdef mswindows}timebeginperiod(1);{$endif}
+end;
+
+procedure endhightimerrate;
+begin
+  {$ifdef mswindows}timeendperiod(1);{$endif}
+end;
+
 procedure init;
 begin
-  {$ifdef win32}timebeginperiod(1);{$endif} //ensure stable unchanging clock
+  {$ifdef btimehighrate}beginhightimerrate;{$endif}
   fillchar(mmtime_driftavg,sizeof(mmtime_driftavg),0);
   settimebias := 0;
   gettimezone;