Я не уверен, что понимаю вашу проблему, но для каждой операции по отдельности вам просто нужно сделать два отдельных цикла.

#include <stdio.h>
#include <time.h>

int main()
{
    long long total1 = 0, total2 = 0, i = 0, j = 1000000000;
    double simulation_time1, simulation_time2;
    clock_t Start, End;

    /* addition */
    Start = clock();
    do
    {
         total1 += i + i;
         i++;
    } while (i < j);
    End = clock();
    simulation_time1 = (double)(End - Start) / CLOCKS_PER_SEC;

    /* multiplication */
    Start = clock();
    do
    {
         total2 += i * i * i * i;
         i++;
    } while (i < j);
    End = clock();
    simulation_time2 = (double)(End - Start) / CLOCKS_PER_SEC;

    printf("Total 1 = %u \n", total1);
    printf("Total 2 = %u \n", total2);
    printf("Runtime of Whole Simulation: %f\n"
        "Runtime of Addition:         %f\n"
        "Runtime of Multiplication:   %f\n",
        simulation_time1 + simulation_time2,
        simulation_time1, simulation_time2);

    return 0;
}

У вас есть две операции, которые вы хотите разделить по времени. Первое — это накопление i+i, а второе — накопление i*i*i*i.

Я предполагаю, что вы используете GCC на x86-64 с -O2.

Если мы закомментируем total2, сгенерированная сборка для вычисления total1 будет следующей:

  movabs rdx, 999999999000000000

Умный компилятор! Он выполняет все вычисления во время компиляции. Таким образом, время, затраченное на это, в основном равно нулю.

Если мы вместо этого закомментируем total1, сборка цикла для вычисления total2 будет следующей:

.L2:
  mov rdx, rax
  imul rdx, rax       ; i squared
  add rax, 1
  imul rdx, rdx       ; i squared squared
  add rsi, rdx        ; accumulate
  cmp rax, 1000000000 ; loop condition
  jne .L2

Вместо того, чтобы пытаться проводить микротестирование отдельных строк кода, мы можем обратиться к таблицам инструкций Agner Fog: https://www.agner.org/optimize/instruction_tables.pdf

Предполагая, что вы используете Intel Haswell и немного распределяете порты вручную, таблицы сообщают нам:

.L2:                  ; ports  cycles  latency
  mov rdx, rax        ; p0     0.25    1
  imul rdx, rax       ; p1     1       3
  add rax, 1          ; p0     0.25    1
  imul rdx, rdx       ; p1     1       3
  add rsi, rdx        ; p0     0.25    1
  cmp rax, 1000000000 ; p5     0.25    1
  jne .L2             ; p6     1-2

Некоторые из этих инструкций могут перекрываться, поэтому на итерацию должно приходиться примерно 3-4 такта ядра. На процессоре с частотой 3-4 ГГц для выполнения одного миллиарда итераций цикла потребуется около 1 секунды.