* Return the current value of the fine-grain CPU cycle counter * (accessed via the RDTSC instruction). */

* Opens a compressed log with contents created by Encoder. * * \param filename * Compressed log file to open * \return * True if succes

* Interprets the uncompressed log messages (created by the compile-time * generated code) contained in the *from buffer and compresses them to * the

* Peek into a data array and identify the next entry embedded in the * compressed log (if there is one) and read it back. * * \param in

* 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

* Retrieve the number of bytes encoded in the internal buffer * * \return * Number of bytes encoded in the internal buffer */

* Given a stream of nibbles, return the total number of bytes used to represent * the values encoded with the nibbles. * * \param nibbles * T

* Complement to reserveProducerSpace that makes nbytes starting * from the return of reserveProducerSpace visible to the consumer.

* Iterative interface to decompress the next log statement (if there are any) * in the log file and optionally prints it via outputFd. The log statem

* Attempt to reserve contiguous space for the producer without making it * visible to the consumer (See reserveProducerSpace). * * This is the slow pa

Returns the runtime timestamp for the log invocation.

Indicates whether the structure stores a valid log statement or not

* Extract the information from an UncompressedLogEntry and re-encode it * as a CompressedRecordEntry. Here, the provided lastTimestamp is provide

* Peek at the data available for consumption within the stagingBuffer. * The consumer should also invoke consume() to release space back * to the prod

* Read in the next buffer fragment from the compressed log. If an error occurs * the file descriptor will be in an undefined state. * * \param fd

* Read in and decompress the log metadata from a CompressedRecordEntry * * \param in * Character array to read the entry from

Returns the preprocessor-assigned log identifier for this log message

* Consumes the next nbytes in the StagingBuffer and frees it back * for the producer to reuse. nbytes must be less than what is

* Reads the metadata necessary to decompress log messsages from a log file. * This function can be invoked incrementally to build a larger dictionary

* Attempt to reserve contiguous space for the producer without * making it visible to the consumer. The caller should invoke

Measure the cost of cpuid

* Attempt to read back the next log statement contained in the BufferFragment, * output the original log message to outputFd, and if applicable, run

* Whether one can invoke decompressNextLogStatement or not */

Measure the cost of copying a given number of bytes with memcpy.

* Reserve/Allocate enough space for N parameters in the structure * * \param nparams * Number of parameters to ensure space for */

Returns the number of arguments currently stored for the log.

* Decompress the log file that was open()-ed and print the message out in * an arbitrary order (i.e. dependent on runtime implementation and not * n

* Extracts a checkpoint from a file descriptor. * * \param[out] cp * Checkpoint structure to read the data into * \param fd

* Reads a partial dictionary from the log file and adds it to the global * mapping of log identifiers to static log information. * * \param fd *

* Ready's the structure for a new log statement by reassigning the static * log information. Dynamic arguments can then be push()-ed into the * stru

* Given a vector of StaticLogInfo and a starting index, encode all the static * log information into a partial dictionary for the Decompressor to use

* Decompress the log file that was open()-ed and print the log messages out * in chronological order. * * \param outputFd * The file descript

* Internal function that encodes a marker indicating that all log messages * after this point (but after the next marker) belong to a particular buff

A safe version of sprintf.

* Return the timestamp of the next log message that can be outputted. It is * the responsibility of the caller to ensure that the BufferFragment cont

* Prints the usage information to stdout. * * \param exe * Name of the executable */

* Allocates a BufferFragment to read BufferExtents into * * \return * Allocated BufferFragment */

* Reads a number of bytes from an fread repeatedly and times it * * \param readSize * Number of bytes to read at once * * \return total

* Internal function to store a BufferFragment on the free list * * \param bf * BufferFragment to store */

* Reads a number of bytes from an ifstream repeatedly and times it * * \param readSize * Number of bytes to read at once * * \return tot

* Return the current value. */

Writes the metadata needed by the decompressor to interpret the log messages generated by compressFn.

* Atomically increment the value by a given amount. * * \param increment * How much to add to the value. If the value is a pointer

* Ask the operating system to pin the current thread to a given CPU. * * \param cpu * Indicates the desired CPU and hyperthread; low order 2 b

* Allocates thread-local structures if they weren't already allocated. * This is used by the generated C++ code to ensure it has space to

* Returns a pointer to to the first byte beyond the last pack()-ed value * * \return * Pointer to the first byte beyond last pack(

* Checks whether a character is a digit (0-9) or not. * * \param c * character to check * \return * true if the character is a digit *

* Measure the cost of copying cpyBytes from cold/hot source/destinations * * \param cpySize * Size of the copy * \param coldSrc *

expr ::= seq ( '|' seq )* ;

long ::= '--' chars [ ( ' ' | '=' ) chars ] ;

seq ::= ( atom [ '...' ] )* ;

shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;