Hi!
Is it safe install two timers that point to the same function?
I want to do something like this:

That's perfectly valid. Try it out

[append]
Oh, well, it's valid, but the address of those two params goes out of scope when the functions return. It will cause lots of crashes later To fix, move the params to a scope that won't be overwritten for the lifetime of the timers (i.e. globals).

Remember that your function must be fast. If it is fast, then you should have no problems.

I'll assume it's OK then. Thanks, guys!

A minor detail
Of course those vars will be global or declared in the main game loop. I missed that in the example above, sorry.

That's the idea, it'll just update some flags.

volatile int[MAX] params;
...
void timer_func(void* p)
{
  int index = *((int*) p);
  ++params[index];
}

The point is I have this doubt mainly because I know nothing about interrupts and threads. I don't know if something weird happens with the stack or whatever when accessing the same function at the same time. My game is still in the design stage, so I don't want any weird bug later.

In most cases they should be called from completely different stacks.

The typical way to solve this problem is pass timer_func a pointer to a struct with all the data you need in it, instead of making global varaibles.

Example:

And again I say: Don't - use - allegro - timers! They're inaccurate, they eat (too) much cpu, and they require extra threads, without removing the need for constant polling (which is the only advantage of using threads after all).
QueryPerformanceCounter() (windows), gettimeofday (linux) are cheaper (in terms of system resources - basically, they run anyway, so all you need to do is read them once per main loop pass), thread-safe, way more accurate (down to a single cpu clock tick) and easier to code (once you wrap them right; do it once and re-use for all future projects). Only fall back on allegro timers if you absolutely have to.

Unless you are making a 3D (especially a FPS), Allegro timers are fine and portable enough.

I completely agree with Rey. I use Allegro timers (and lots of them) for all of my games, and they work perfectly. They exist for a reason, despite their few shortcomings, and if you understand how they work and how they are meant to be deployed you won't have any problems. If the situation demands a different approach (such as complex 3D systems), take it.

Edited for clarity.

If anybody had some framework for basic QPC/gettimeofday that can be reused easily, that would be nice.

Search for timer in the forum and write your own.

All of Allegro's timers run on a single thread. And since some of Allegro's internals use timers, that thread is already created.

This is what I use:
timer.h:

#ifndef TIMER_H
#define TIMER_H

void init_timer(bool use_qpc = false);
void stop_timer();
void start_timer(int timer_ms);
float get_timer_delta();
const char* get_timing_method_string();
float get_timer_accuracy();

#endif

timer.cpp:

Uses QPC in windows if asked to, and falls back on allegro timers otherwise.
Doesn't support gettimeofday() yet, since I don't have a linux box running, but it can easily be extended. You can also hack it at will to use integers to represent time, or libc-time, or whatever you please. You may also want to put the whole thing into a class, or make it C-friendly.
Oh yes, and feel free to re-use.

Put it in my domain's temp folder. If you want to mirror it baf it would last longer:
http://wipproject.zapto.org/tmp/timer.h
http://wipproject.zapto.org/tmp/timer.cpp

Usage:

#include "timer.h"

int main() {
  printf("%u seconds or %u milliseconds or %u microseconds since program start",
    timer.secs(),
    timer.msecs(),
    timer.usecs());
}