ich setze mich gerade mit multicore programmierung auseinander und fand da ein paar nette ansätze (active object etc.)

was mir besonders ins auge gestochen ist waren goroutines von google's go.

kurze erklärung:

goroutines sind user-threads die über spezielle variablen, so genannte channels mit einander kommunizieren können.

diese user-threads werden sprachintern über "echte" threads verteilt.

so bekommt man auf der einen seite den vorteil, dass das OS die threads auf die verschiedenen cores verteilen kann und der kram so zu sagen parallel laufen kann.

und man hat den vorteil von user-threads, die vom OS keinen context-switch verlangen, weil sie von der software selbst verwaltet werden. so sind wesentlich mehr goroutines möglich als threads sinnvoll wären.

erlang hat scheinbar ein ähnliches modell...

wollt nur wissen, ob es ähnliche möglichkeiten auch für C++ gibt. also irgend eine lib oder sowas

Wobei die Kommunikation ueber Channels bei Erlang und Go komfortabler ist als es in C++ moeglich ist. Aber funktionieren tut es auch in C++ ganz ok.

ich setze mich gerade mit multicore programmierung auseinander [...] goroutines [...] wollt nur wissen, ob es ähnliche möglichkeiten auch für C++ gibt. also irgend eine lib oder sowas

In der nächsten C++ Version sollte sich das alles mehr oder weniger elegant emulieren lassen, denke ich. Aber Go hat, was das angeht, sicherlich den süßeren Syntaxzucker.

func DoSomething(done chan <- int) {
  // do some processing...
  done <- 1;
}

func main() {
  done := make(chan int, 1);
  go DoSomething(done);
  // do something else
  <-done;  // wait
  // do more things
}

könnte man vielleicht auch so in C++0x machen:

void DoSomething(chan<int> done) {
  // do some processing...
  done << 1;
}

int main() {
  auto done = make_chan<int>(1);
  auto futu = async(DoSomething,done);
  done.read(); // wait
  futu.get(); // retrieve the function's result from the future
}

wobei ich das Klassentemplate chan<> und das Funktionstemplate make_chan<> frei erfunden habe. Es müsste aber möglich sein, sie so zu definieren, dass hier genau das passiert, was man erwarten würde. Natürlich ist hier der "done-Channel" wegen dem future-Objekt überflüssig. Was allerdings passiert, wenn das future-Objekt zerstört wird, bevor die Ausführung von DoSomething fertig ist, weiß ich nicht. Müsste man mal nachgucken. Eventuell ist das nicht erlaubt. Man kann aber auch relativ einfach einen Ersatz für std::async schreiben, der das verkraften würde.

... nur mal so um auf den Geschmack von C++0x zu kommen ...