Die Ergebnisse werden nur sehr selten benötigt, daher sind die Aufrufe von LowerScore() und UpperScore() fast zu vernachlässigen.

#include <stdio.h>

const uint32_t ZERO_LOWER_SCORE = (1UL << 15);
const uint32_t ZERO_UPPER_SCORE = (1UL << 31);
const uint32_t ZERO_SCORE = ZERO_LOWER_SCORE + ZERO_UPPER_SCORE;

inline uint32_t MakeScore(int lower, int upper) {
  return static_cast<uint32_t>(lower) + (static_cast<uint32_t>(upper) << 16);
}

inline int LowerScore(Score score) {
  return (score & 0xFFFF) - ZERO_LOWER_SCORE;
}

inline int UpperScore(Score score) {
  return (score >> 16) - ZERO_LOWER_SCORE;
}

int main() {
  uint32_t s = ZERO_SCORE;
  // Do +- operations in parallel.
  s -= MakeScore(120, 18);
  printf("lower = %d upper = %d\n", LowerScore(s), UpperScore(s));
  return 0;
}

// Output: lower = -120 upper = -18

Danke für eure Hilfe!

Thats the purpose.

vector<short>

hast, sollte mit der entsprechenden Compiler-Option schon SSE genommen werden. Darüber hinaus kannst Du Dir noch OpenMP anschauen, da gibt es ein parallel_for, dass das für Deine Zwecke richtige macht.

Weil negieren (~) etwas anderes ist, als den negativen Wert (*= -1) zu bilden (zumindest auf den meisten modernen CPU Architekturen). In einer Zeit als Männer noch Männer und die Schafe sehr nervös waren, war das auch schon mal anders.

wo willst du da performance optimieren?
eine addition (und damit auch subtraktion) ist doch die atomarste operation auf einem pc (oder irre ich mich da? war jedenfalls letztens in der fh noch so)

das einzige was es bringen könnte wäre, wenn du die paar millionen aufrufe in eine formel quetscht, die dann einmal berechnet wird und das ergebnis kommt raus...

wo willst du da performance optimieren?

Die Idee ist dass 500.000 Additionen schneller sind als 1.000.000...Die Antwort ist natürlich SSE und das Stichwort ja bereits gefallen.