How the complexity of the following code is O(nlogn)?

First, we need to estimate number of high-level operations executed for different n. In this case the inner loop is an operation that you want to count, if I understood the question right.

If it is difficult, you may automate it. I used Matlab for example code since there was no tag for specific language. Testing code will look like this:

    % Reasonable amount of input elements placed in array, change it to fit your needs
    x = 1:1:100;
    % Plot linear function
    plot(x,x,'DisplayName','O(n)', 'LineWidth', 2);
    hold on;
    % Plot n*log(n) function
    plot(x, x.*log(x), 'DisplayName','O(nln(n))','LineWidth', 2);
    hold on;
    % Apply our function to each element of x
    measured = arrayfun(@(v) test(v),x);
    % Plot number of high level operations performed by our function  for each element of x
    plot(x,measured, 'DisplayName','Measured','LineWidth', 2);
    legend
    
    % Our function
    function k = test(n)
    % Counter for operations
    k = 0;
    % Outer loop, same as for(i=1;i<=n;i=i*2) 
    i = 1;
    while i < n
      % Inner loop  
      for j=1:1:i
          % Count operations
          k=k+1;
      end
    i = i*2;
    end
    end

And the result will look like

Our complexity is worse than linear but not worse than O(nlogn), so we choose O(nlogn) as an upper bound.

Time complexity in terms of what? If you want to know how many inner loop operations the algorithm performs, it is not O(n log n). If you want to take into account also the arithmetic operations, then see further below. If you literally are to plug in that code into a programming language, chances are the compiler will notice that your code does nothing and optimise the loop away, resulting in constant O(1) time complexity. But only based on what you've given us, I would interpret it as time complexity in terms of whatever might be inside the inner loop, not counting arithmetic operations of the loops themselves. If so:

Consider an iteration of your inner loop a constant-time operation, then we just need to count how many iterations the inner loop will make.

You will find that it will make

1 + 2 + 4 + 8 + ... + n

iterations, if n is a square number. If it is not square, it will stop a bit sooner, but this will be our upper limit.

We can write this more generally as

the sum of 2ⁱ where i ranges from 0 to log₂n.

Now, if you do the math, e.g. using the formula for geometric sums, you will find that this sum equals

2n - 1.

So we have a time complexity of O(2n - 1) = O(n), if we don't take the arithmetic operations of the loops into account.

If you wish to verify this experimentally, the best way is to write code that counts how many times the inner loop runs. In javascript, you could write it like this:

function f(n) {
    let c = 0;
    for(i=1;i<=n;i=i*2) {
      for(j=1;j<=i;j++) {
          ++c;
      }
    }
    console.log(c);
}

f(2);
f(4);
f(32);
f(1024);
f(1 << 20);

If you do want to take the arithmetic operations into account, then it depends a bit on your assumptions but you can indeed get some logarithmic coefficients to account for. It depends on how you formulate the question and how you define an operation.

Furthermore the upper bound should be:

O(n*log2(n))

The worst case is n being in 2^x. x€real numbers

The inner loop is evaluated n times, the outer loop log2 (logarithm basis 2) times.