Rubygems | Latest Versions for hitimeshttps://rubygems.org/gems2023-09-30T06:44:21Zhitimes (2.0.0)https://rubygems.org/gems/hitimes/versions/2.0.02019-09-23T13:08:44ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.1-java)https://rubygems.org/gems/hitimes/versions/1.3.1-java2019-01-18T17:20:08ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.1-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.3.1-x86-mingw322019-01-18T17:28:40ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.1-x64-mingw32)https://rubygems.org/gems/hitimes/versions/1.3.1-x64-mingw322019-01-18T17:28:55ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.1)https://rubygems.org/gems/hitimes/versions/1.3.12019-01-18T17:17:13ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.0)https://rubygems.org/gems/hitimes/versions/1.3.02018-06-15T21:57:36ZJeremy Hinegardner[![Build Status](https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes)
(https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes) A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.0-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.3.0-x86-mingw322018-06-15T22:28:08ZJeremy Hinegardner[![Build Status](https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes)
(https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes) A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.0-x64-mingw32)https://rubygems.org/gems/hitimes/versions/1.3.0-x64-mingw322018-06-15T22:28:24ZJeremy Hinegardner[![Build Status](https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes)
(https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes) A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.3.0-java)https://rubygems.org/gems/hitimes/versions/1.3.0-java2018-06-15T21:58:44ZJeremy Hinegardner[![Build Status](https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes)
(https://travis-ci.org/copiousfreetime/hitimes.svg?branch=master)](https://travis-ci.org/copiousfreetime/hitimes) A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.6)https://rubygems.org/gems/hitimes/versions/1.2.62017-08-04T15:17:50ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.6-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.2.6-x86-mingw322017-08-04T15:25:29ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.6-java)https://rubygems.org/gems/hitimes/versions/1.2.6-java2017-08-04T15:20:07ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.5)https://rubygems.org/gems/hitimes/versions/1.2.52017-05-25T21:03:52ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.5-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.2.5-x86-mingw322017-05-25T21:04:57ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.5-java)https://rubygems.org/gems/hitimes/versions/1.2.5-java2017-05-25T21:10:29ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.4)https://rubygems.org/gems/hitimes/versions/1.2.42016-05-03T04:48:39ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.4-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.2.4-x86-mingw322016-05-03T04:50:55ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.4-java)https://rubygems.org/gems/hitimes/versions/1.2.4-java2016-05-03T13:34:36ZJeremy HinegardnerA fast, high resolution timer library for recording peformance metrics.
A fast, high resolution timer library for recording peformance metrics. * (http://github.com/copiousfreetime/hitimes) * (http://github.com.org/copiousfreetime/hitimes) * email jeremy at copiousfreetime dot org * `git clone url git://github.com/copiousfreetime/hitimes.git` hitimes (1.2.3)https://rubygems.org/gems/hitimes/versions/1.2.32015-09-13T07:49:44ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.3-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.2.3-x86-mingw322015-09-13T07:58:53ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.3-java)https://rubygems.org/gems/hitimes/versions/1.2.3-java2015-09-13T07:58:44ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.2)https://rubygems.org/gems/hitimes/versions/1.2.22014-07-09T21:24:20ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.2-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/1.2.2-x86-mswin32-602015-01-06T21:34:43ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.2-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.2.2-x86-mingw322015-01-12T03:24:14ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.2-java)https://rubygems.org/gems/hitimes/versions/1.2.2-java2014-07-09T21:40:22ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.1)https://rubygems.org/gems/hitimes/versions/1.2.12013-03-12T14:37:30ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.1-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.2.1-x86-mswin322013-03-12T16:21:19ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.1-java)https://rubygems.org/gems/hitimes/versions/1.2.1-java2013-03-12T16:26:41ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`. hitimes (1.2.0-java)https://rubygems.org/gems/hitimes/versions/1.2.0-java2013-02-09T07:04:07ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.2.0)https://rubygems.org/gems/hitimes/versions/1.2.02013-02-09T07:02:26ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.2.0-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.2.0-x86-mswin322013-02-09T07:07:25ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible.
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate low method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.1.1-java)https://rubygems.org/gems/hitimes/versions/1.1.1-java2010-09-06T20:23:08ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate low method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
* JRuby
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.1-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.1.1-x86-mswin322010-09-06T20:21:16ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate low method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
* JRuby
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.1-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.1.1-x86-mingw322010-09-06T20:21:10ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate low method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
* JRuby
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.1)https://rubygems.org/gems/hitimes/versions/1.1.12010-09-04T22:21:35ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.0)https://rubygems.org/gems/hitimes/versions/1.1.02010-07-29T02:30:16ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.0-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.1.0-x86-mswin322010-07-29T02:32:15ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.0-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.1.0-x86-mingw322010-07-29T02:31:59ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.1.0-java)https://rubygems.org/gems/hitimes/versions/1.1.0-java2010-07-29T02:42:18ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.0.5-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.0.5-x86-mingw322010-07-21T05:27:03ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.0.5-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.0.5-x86-mswin322010-07-21T05:27:15ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.0.5)https://rubygems.org/gems/hitimes/versions/1.0.52010-07-21T05:25:51ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording
performance metrics. It uses the appropriate C method calls for each
system to get the highest granularity time increments possible.
It currently supports any of the following systems:
* any system with the POSIX call <tt>clock_gettime()</tt>,
* Mac OS X
* Windows
Using Hitimes can be faster than using a series of +Time.new+ calls, and
it will have a much higher granularity. It is definitely faster than
using +Process.times+. hitimes (1.0.4-x86-mingw32)https://rubygems.org/gems/hitimes/versions/1.0.4-x86-mingw322009-09-24T22:10:57ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.4-x86-mswin32)https://rubygems.org/gems/hitimes/versions/1.0.4-x86-mswin322009-09-24T22:11:01ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.4)https://rubygems.org/gems/hitimes/versions/1.0.42009-08-05T00:29:52ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.3-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/1.0.3-x86-mswin32-602009-09-24T22:10:56ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.3)https://rubygems.org/gems/hitimes/versions/1.0.32009-08-05T00:29:57ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.2-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/1.0.2-x86-mswin32-602009-09-24T22:10:56ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call <tt>clock_gettime()</tt>, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.2)https://rubygems.org/gems/hitimes/versions/1.0.22009-08-05T00:30:01ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.1-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/1.0.1-x86-mswin32-602009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.1)https://rubygems.org/gems/hitimes/versions/1.0.12009-07-25T18:14:16ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.0-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/1.0.0-x86-mswin32-602009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (1.0.0)https://rubygems.org/gems/hitimes/versions/1.0.02009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any of the following systems: * any system with the POSIX call &lt;tt&gt;clock_gettime()&lt;/tt&gt;, * Mac OS X * Windows Using Hitimes can be faster than using a series of +Time.new+ calls, and it will have a much higher granularity. It is definitely faster than using +Process.times+. hitimes (0.4.1-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/0.4.1-x86-mswin32-602009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime(), Mac OS X and Windows. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.4.1)https://rubygems.org/gems/hitimes/versions/0.4.12009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime(), Mac OS X and Windows. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.4.0-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/0.4.0-x86-mswin32-602009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime(), Mac OS X and Windows. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.4.0)https://rubygems.org/gems/hitimes/versions/0.4.02009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime(), Mac OS X and Windows. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.3.0)https://rubygems.org/gems/hitimes/versions/0.3.02009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime() and OSX. Windows is in the works. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.3.0-x86-mswin32-60)https://rubygems.org/gems/hitimes/versions/0.3.0-x86-mswin32-602009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime() and OSX. Windows is in the works. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.2.1)https://rubygems.org/gems/hitimes/versions/0.2.12009-07-25T18:14:17ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime() and OSX. Windows is in the works. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times. hitimes (0.2.0)https://rubygems.org/gems/hitimes/versions/0.2.02009-07-25T18:14:18ZJeremy HinegardnerHitimes is a fast, high resolution timer library for recording performance metrics
Hitimes is a fast, high resolution timer library for recording performance metrics. It uses the appropriate C method calls for each system to get the highest granularity time increments possible. It currently supports any system with the POSIX call clock_gettime() and OSX. Windows is in the works. Using Hitimes can be faster than using a series of Time.new calls, and it will have a much higher granularity. It is definitely faster than using Process.times.