3. Parallel addieren und subtrahieren

Parallel addieren und subtrahieren

  • T

    Ich suche nach einer portablen Möglichkeit zwei 16-Bit Ints (-32768 bis +32767) *parallel* zu addieren oder zu subtrahieren. Gibt es hierfür eine effiziente Möglichkeit?

    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!

    0
  • T

    Was genau soll daran parallel sein? Und wozu willst Du das machen? Performance? Platz sparen?

    0
  • T

    Angenommen bei einem Wertepaar (Zwei int16_t) müssen mehrere Mio Additionen und Subtraktionen durchgeführt werden, bevor das Wertepaar zum ersten mal ausgewertet wird. Dann könnte es doch laufzeiteffizienter sein nur noch die Hälfte der Operationen aber mit nur noch einem uint32_t durchzuführen.

    Thats the purpose.

    0
  • T

    Natürlich hat obige simple Implementierung einen grossen Haken: Man kann immer nur positive Zahlenpaare addieren oder subtrahieren, aber keine negativen.
    😕

    0
  • O

    Solche sachen können doch von mmx oder sse gemacht werden. Und wenn du nur ne einfache Schleife hast würde der compiler auch für mmx oder sse optimieren können.

    0
  • ?

    wenn Du einen

    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.

    0
  • C
    Mod

    Wieso nicht einfach den Subtrahenden negieren, anschließend aus den Subtraktionen Additionen machen und das Ergebnis zum Schluss wieder negieren? Damit handelt es sich nur noch um Additionen auf zwei Werten, was auf einfache Weise vektorisiert werden kann.

    0
  • ?

    @camper:

    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.

    0
  • ?

    camper meint hier mit "negieren" ganz sicherlich "negativen Wert bilden".

    0
  • S

    mh du sprichst von 2 16bit operationen, also eine 32 bit zahl

    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...

    0

  • Skym0sh0 schrieb:

    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.

    0
Anmelden zum Antworten