Programming

achenle,

Thanks for quite detailed response.

I was thinking about a similar solution. Apart from getting logs in string format, syslogd process works in similar fashion. Which mandates lot of context switches between syslogd process and measured process.

I am thinking of creating a thread to do logging rather than a process, so as to reduce process context switch.

Any comments?

I decided to go with the binary structure.

Which one will be better to send measurements from measured thread to logging thread?
Shared memory with mutex or Non blocking messages(pipe,...)

/Tamil

I think because you are using a binary struct it will write the data as a reserved block in the pipe and you won't need mutex because the data won't overlap.
I may be wrong about that.

Venam,

Mutex should be used in the case of shared memory.

For instance, an external structure array can be updated by measured thread and read(remove) by logging thread ( with mutex to avoid race condition)

I agree, there is no need of mutex in case of message transmission.

/Tamil

Well that would depend on what exact 'shared memory' model you are going to use and frequency of the logging code. Also you might want to consider sampling algorithm if the code runs at very high frequency on a production platform, that basically means that you only measure every Nth run and its much more suitable for logging for extended amount of time a piece of code that is very frequent.

Another suggestion:
Sometimes real time execution results can be not very meaningful for fast sections of code due to thread scheduler making them apear random on a busy system, you should probably instead log CPU time (CPU Time - The GNU C Library) as it has more meaning.

Well, you'd probably wind up blocking on the mutex at times, while you should never block on the write.

Also, if you do your logging in a separate process, if there's a bug in it that causes a process crash (SEGV, etc), then you won't bring down your production process(s).

Compare that against the context switching needed for a separate process.

Without knowing your hardware and software, I can't really comment on which would be better for you and your processing.

Thanks achenle and expl,

Sorry for the delayed reply.

Since the measurement is done for research prototype, its very controlled process. Hence I decided to go for mutex based solution. In a process, many threads are measured (thread logs time taken by them to an dynamic array) and a one thread removes elements from array and writes to a log file.

Since measurement tends to get the system performance, I decided to use time(NULL) to log the time. Any suggestions?

/T

If accuracy down to just a second is good enough, that'll work. If you need or want more accuracy, you can use "clock_gettime()", assuming you're running on a Linux-based system. On Solaris or HPUX you could use "gethrtime()".

Those would give you timestamps down to nanoseconds, although they are probably not that accurate in reality.