* A compiler barrier preventing compiler reordering */

* Compares two BufferFragments (a, b) based on the timestamps of * their next decompress-able log statements. Returns true if * a's timestamp chrono

* Atomically compare the value with a test value and, if they match, * replace the value with a new value. * * \param test *

* Main compression thread that handles scanning through the StagingBuffers, * compressing log entries, and outputting a compressed log file. */

* Generate a more efficient internal representation describing how to process * the compressed arguments of a NANO_LOG statement given its static *

* Creates a thread-private TimeTrace::Buffer object for the current thread, * if one doesn't already exist. */

* Decompress the file open()-ed to a file descriptor. This invocation will * not attempt to sort the log entries by time, but otherwise functions *

* This function just discards its argument. It's used to make it * appear that data is used, so that the compiler won't optimize * away the code we

Measure the cost of a 32-bit divide. Divides don't take a constant number of cycles. Values were chosen here semi-randomly to depict a fairly expensiv

Measure the cost of a 64-bit divide. Divides don't take a constant number of cycles. Values were chosen here semi-randomly to depict a fairly expensiv

* This method provides appropriate fencing for the beginning of a critical * section. Normally this method is invoked immediately after performi

* Atomically replace the value while returning its old value. * * \param newValue * This value will replace the current value.

* Complement to reserveAlloc, makes the bytes previously * reserveAlloc()-ed visible to the compression/output thread. * *

Flush the CPU data cache by reading and writing 100MB of new data.

* Given a number of nanoseconds, return an approximate number of * cycles for an equivalent time length. * \param ns * Number of nanoseconds.

* Given a time in seconds, return the number of cycles that it * corresponds to. * \param seconds * Time in seconds. * \param cyclesPerSec *

This function takes somewhere between 9-10 on average.

Measure the cost of calling a non-inlined function.

* Returns the cpu affinity mask of the currently executing thread. The type * cpu_set_t encodes information about which cores the current thread is

* Returns the conversion factor between cycles in seconds, using * a mock value for testing when appropriate. */

* Returns a string detailing the distribution of how long vs. how many times * the log producers had to wait for free space and how big vs. how many

Documentation in NanoLog.h

* Return a string containing all of the trace records from all of the * thread-local buffers. */

* Return (potentially multi-line) string hex dump of a binary buffer in * 'hexdump -C' style. * Note that this exceeds 80 characters due to 64-bit o

Measure the cost of reading high precision time

* Atomically increment the current value (for pointer types the * increment is the size of the referent type; otherwise the increment * is 1

* Perform once-only overall initialization for the Cycles class, such * as calibrating the clock frequency. This method is invoked automatically *

* Insert a checkpoint into an output buffer. This operation is fairly * expensive so it is typically performed once per new log file. * * \param ou

* This method provides appropriate fencing for the end of a critical * section. Normally this method is invoked immediately prior to releasing

* This method creates a boundary across which load instructions cannot * migrate: if a memory read comes from code occurring before (after)

* Simple program to decompress log files produced by the NanoLog System. * Note that this executable must be compiled with the same BufferStuffer.h

Measure the time to create and delete an entry in a small map.

Measure the time to lookup a random element in a small map.