Home/ Questions/Q 108119
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-11T01:51:42+00:00

My application runs on a pSOS operating system. The code is compiled with Diab

  • 0

My application runs on a pSOS operating system. The code is compiled with Diab C compiler.

The application defines a number of counters which have been declared as 

unsigned int call_count;

As there are chances of some of these overflowing in a small time frame, I have decided to declare the counters as 

unsigned long long int call_count;

This I believe would not overflow at least during my lifetime.

My question is this conversion harmless? Are there any overhead that I need to concerned with. When the application is under stress the call_count would be incremented incessantly. Can performance take a hit ? A SNMP manager would be querying these counters every 15 seconds as well.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Is your code assuming that incrementing a 32-bit variable is an atomic operation? Incrementing a 64-bit variable on a 32-bit CPU probably won’t be atomic unless you go out of your way to make it so.

    Example:

    1. call_count equals 0x00000005FFFFFFFF when a call comes in.
    2. The lower half of call_count is incremented: call_count gets set to 0x000000500000000 and the CPU’s carry bit gets set to 1.
    3. The upper half of call_count is incremented by the carry bit: call_count gets set to 0x0000000600000000.

    If another thread or an interrupt handler reads the value of call_count between steps 2 and 3, it will get the wrong result (0x000000500000000 instead of 0x000000600000000). The solution is to synchronize access to call_count. A few possibilities:

    • Disable interrupts (if appropriate)
    • Serialize access using a lock
    • Read and write using atomic/interlocked functions (example: InterlockedIncrement() on Windows)
    • 0