- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files
- Examples

Typedefs | Functions
Counter
Eina » Tools

This group discusses the functions that allow you to get the time spent in a part of a code. More...

## Typedefs
typedef struct _Eina_Counter | Eina_Counter
| Type for Counter.

## Functions
EAPI Eina_Counter * | eina_counter_new (const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1)
| Return a counter. More...
EAPI void | eina_counter_free (Eina_Counter *counter) EINA_ARG_NONNULL(1)
| Delete a counter. More...
EAPI void | eina_counter_start (Eina_Counter *counter) EINA_ARG_NONNULL(1)
| Start the time count. More...
EAPI void | eina_counter_stop (Eina_Counter *counter, int specimen) EINA_ARG_NONNULL(1)
| Stop the time count. More...
EAPI char * | eina_counter_dump (Eina_Counter *counter) EINA_ARG_NONNULL(1)
| Dump the result of all clocks of a counter to a stream. More...

## Detailed Description

This group discusses the functions that allow you to get the time spent in a part of a code.

Before using the counter system, Eina must be initialized with eina_init() and later shut down with eina_shutdown(). To create a counter, use eina_counter_new(). To free it, use eina_counter_free().

To time a part of a code, call eina_counter_start() just before it, and eina_counter_stop() just after it. Each time you start to time a code, a clock is added to a list. You can give the number of that clock with the second argument of eina_counter_stop(). To send all the registered clocks to a stream (like stdout, for a file), use eina_counter_dump().

Here is a straightforward example:

#include <stdlib.h>
#include <stdio.h>
#include <eina_counter.h>
void test_malloc(void)
{
int i;
for (i = 0; i < 100000; ++i)
{
void *buf;
buf = malloc(100);
free(buf);
}
}
int main(void)
{
Eina_Counter *counter;
if (!eina_init())
{
printf("Error during the initialization of eina\n");
return EXIT_FAILURE;
}
counter = eina_counter_new("malloc");
eina_counter_start(counter);
test_malloc();
eina_counter_stop(counter, 1);
char* result = eina_counter_dump(counter);
printf("%s", result);
free(result);
eina_counter_free(counter);
eina_shutdown();
return EXIT_SUCCESS;
}

Compile this code with the following command:

    * gcc -Wall -o test_eina_counter test_eina.c `pkg-config --cflags --libs eina`
    *

The result should be something like this:

    * \# specimen    experiment time    starting time    ending time
    * 1              9794125            783816           10577941
    *

Note
  The displayed time is in nanoseconds.

## Function Documentation

EAPI Eina_Counter* eina_counter_new | ( | const char * | name | ) |

Return a counter.

Parameters

  name | The name of the counter.

Returns
  A newly allocated counter.

This function returns a new counter. It is characterized by `name`. If `name` is `NULL`, the function returns `NULL` immediately. If memory allocation fails, `NULL` is returned.

Whe the new counter is not needed anymore, use eina_counter_free() to free the allocated memory.

Referenced by eina_benchmark_run().

EAPI void eina_counter_free | ( | Eina_Counter * | counter | ) |

Delete a counter.

Parameters

  counter | The counter to delete.

This function remove the clock of `counter` from the used clocks (see eina_counter_start()) and frees the memory allocated for `counter`. If `counter` is `NULL`, the function returns immediately.

References eina_inlist_remove().

Referenced by eina_benchmark_run().

EAPI void eina_counter_start | ( | Eina_Counter * | counter | ) |

Start the time count.

Parameters

  counter | The counter.

This function specifies that the part of the code beginning just after its call is being to be timed, using `counter`. If `counter` is `NULL`, this function returns immediately.

This function adds the clock associated to `counter` in a list. If the memory needed by that clock can not be allocated, the function returns and nothing is done.

To stop the timing, eina_counter_stop() must be called with the same counter.

References EINA_FALSE, EINA_INLIST_GET, and eina_inlist_prepend().

Referenced by eina_benchmark_run().

EAPI void eina_counter_stop | ( | Eina_Counter * | counter,
|  | int | specimen
| ) |  |

Stop the time count.

Parameters

  counter | The counter.
  specimen | The number of the test.

This function stop the timing that has been started with eina_counter_start(). `counter` must be the same than the one used with eina_counter_start(). `specimen` is the number of the test. If `counter` or its associated clock are `NULL`, or if the time can't be retrieved the function exits.

References EINA_TRUE.

Referenced by eina_benchmark_run().

EAPI char* eina_counter_dump | ( | Eina_Counter * | counter | ) |

Dump the result of all clocks of a counter to a stream.

Returns
  A string with a summary of the test.

Parameters

  counter | The counter.

This function returns an malloc'd string containing the dump of all the valid clocks of `counter`. If `counter` `NULL`, the functions exits immediately. Otherwise, the output is formattted like that:

    * \# specimen    experiment time    starting time    ending time
    * 1              208                120000           120208
    *

The unit of time is the nanosecond.

References EINA_FALSE, and EINA_INLIST_REVERSE_FOREACH.

Referenced by eina_benchmark_run().