What input to sprintf would produce 0 result?

Question

I am trying to debug a problem unrelated to this specific code and I am looking for clues, the clue being "what value might this counter have had?" The following line of code

sprintf(strAtLeast10long, "%lld%c%.02uP", 
   input/peta, decimal, (long)((input%peta) / (peta/hundred)));

is producing "0.00P" for output.

Here is what I know about the parameters. Input is an unsigned long long with a value >= (10^12 - (10^7 / 2)). decimal = '.'

static const long long hundred =            100;
static const long long peta =  1000000000000000ULL;

Yes, I know the "%lld" would be better as "%llu" and I will fix that.

But meanwhile, I am looking for clues as to what might have been in input. The problem occurred at a customer and we do not know how to reproduce it, so adding debugging code or using a debugger is not an option.

Compiler is the IBM z/OS C++ compiler. Before you all roll your eyes and go "EBCDIC is the devil's handiwork!" it is a Posix-conformant C++ compiler and environment.

Answer 1

Using all the information you provide in the most straight forward way yields the described output 0.00P for
unsigned long long input=999995000000ULL; (which I understand to be the lowest allowed value in your given scope)
and for
unsigned long long input=9999999999999ULL;, which I believe to be the highest value for the specified output.
It is reasonable to assume that any value in between also gives the same output.

You get 0.01P for unsigned long long input = 10000000000000ULL;, which is one higher.

Here is my playcode,
please check for any conflict with what you described
(I adapted the format specifier string to my compiler, gcc version 4.9.2 (tdm-1), Target: mingw32 ).

#include <stdio.h>

int main(void)
{
    char decimal='.';

    char strAtLeast10long[]="                                \0";
    static const long long hundred =            100;
    static const long long peta =  1000000000000000ULL; 

    //unsigned long long input=  9999999999999ULL;
    //unsigned long long input=   999995000000ULL;
    unsigned long long input  = 10000000000000ULL;

    sprintf(strAtLeast10long, "%I64u%c%.02luP", input/peta, decimal, (long)((input%peta) / (peta/hundred)));

    printf("%s\n", strAtLeast10long );

    return 0;
}

This answer agrees with the comment by xing, which has appeared meanwhile.

Answer 2

The first requirement for that output is:

char decimal = '.';

Then every input value in the range:

0 to (1000000000000000ULL/100 - 1)

or equivalent

0 to 10^13-1

will set the string to:

0.00P

This is because input needs to be lower than:

peta/hundred

which is 1000000000000000ULL/100

Since OP knows that input >= (10^12 - (10^7 / 2)) the final answer is:

input in the range (10^12 - (10^7 / 2)) to 10^13-1 will produce 0.00P

UPDATE

In a comment below OP changes the restriction on input so that input >= (10^15 - (10^7 / 2)) (notice 10^15 instead of 10^12 which differ from the question).

With that new restriction there are no input value that can produce the result 0.00P

In order to get the first 0 (which comes from input/peta) it is obvious that input must be less than peta.

The new requirement from OP is that input >= peta - 10000000ULL so the only interesting range is:

peta - 10000000ULL <= input <= peta - 1

All values in that range produce the result 0.99P.

Conclusion: With the given (new) restrictions there are no input value that can produce the said result

Answer 3

Sometimes one can use brute force testing.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void foo(unsigned i, unsigned long long input) {
  char decimal = '.';
  static const long long hundred = 100;
  static const long long peta = 1000000000000000ULL;
  char strAtLeast10long[10 + 100];

  // compile time warnings
  sprintf(strAtLeast10long, "%lld%c%.02uP", input / peta, decimal,
      (long) ((input % peta) / (peta / hundred)));

  if (strcmp("0.00P", strAtLeast10long) == 0) {
    printf("%u %llu %s\n", i, input, strAtLeast10long);
    fflush(stdout);
  }
}

unsigned long long rand_ull(void) {
  unsigned long long r = 0;
  for (unsigned i = 0; i < sizeof r; i++) {
    r *= 256;
    r ^= (unsigned) rand();
  }
  return r;
}

int main(void) {
  for (unsigned i = 0; i < 10000000; i++) {
    foo(i, rand_ull());
  }
  return 0;
}

Output

486814 1708844199629 0.00P
984885 8152599175962 0.00P
6266031 209118104328 0.00P
7365558 3983123923889 0.00P

Answer 4

I found the value in the counter in the blowup in question via an unrelated route. It is FWIW 0xFFFFFFFFFFFFFA67 or 18446744073709550183. The rounding code wraps it around to 0x0000048c27394a67 or 4999999998567 which is so small (!) it formats as 0.00P.

Sorry I didn't do a better job of describing the problem. The huge powers of 10 are a PITA to keep straight and to type correctly.