Nachdem ich in meinem letzten Artikel Neuerungen in C++26: Datenparallele Typen (SIMD) eine theoretische Einführung in das neue Feature von C++ 26 gegeben habe, möchte ich heute mit einem praktischen Beispiel fortfahren.

Das folgende Einführungsbeispiel stammt aus der experimentellen Implementierung der SIMD-Bibliothek. Diese Funktionalität wurde unter dem Namen „Data-parallel types (SIMD)“ vollständig in den Entwurf für C++ 26 übernommen. Um das Programm auf den C++ 26-Standard zu portieren, sollte es ausreichen, den Header durch und den Namespace std::experimental durch std::datapar zu ersetzen.

#include 
#include 
#include 
namespace stdx = std::experimental;
 
void println(std::string_view name, auto const& a)
{
    std::cout << name << „: “;
    for (std::size_t i{}; i != std::size(a); ++i)
        
std::cout << a[i] << ‚ ‘;
    std::cout << ‚\n‘;
}
 
template
stdx::simd my_abs(stdx::simd x)
{
    where(x < 0, x) = -x;
    return x;
}
 
int main()
{
    const stdx::native_simd a = 1;
    println(„a“, a);
 
    const stdx::native_simd b([](int i) { return i - 2; });
    println(„b“, b);
     
const auto c = a + b;
    println(„c“, c);
 
const auto d = my_abs(c);
println(‚d‘, d);
 
const auto e = d * d;
println(„e“, e);
     
const auto inner_product = stdx::reduce(e);
    std::cout << „inner product: “ << inner_product << ‚\n‘;
 
const stdx::fixed_size_simd x([](int i) { return i; });
println(„x“, x);
    
println(„cos²(x) + sin²(x)“, stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::sin(x), 2));
}

Bevor ich mit dem Programm fortfahre, möchte ich die Ausgabe vorstellen.

Zuerst möchte ich mich den Funktionen println und my_abs widmen. println gibt den Namen und den Inhalt eines SIMD-Vektors aus und durchläuft dabei dessen Elemente. my_abs berechnet den Absolutwert jedes Elements in einem SIMD-Vektor mit Ganzzahlen und verwendet dabei where, um negative Werte bedingt zu negieren. Deutlich interessanter ist die main-Funktion.

Bei dem SIMD-Vektor a wird jedes Element auf 1 gesetzt, hingegen wird bei dem SIMD-Vektor b dank der Lambda-Funktion jedes Element so initialisiert, dass dieses seinen Index minus 2 besitzt. Dabei kommen per Default durch const stdx::native_simd SSE2-Instruktionen zum Einsatz. Diese SIMD-Vektoren sind 128 Bit groß.

Nun beginnt die Arithmetik. Vektor c ist die elementweise Summe von a und b, d ist der elementweise absolute Wert von c und der Vektor e ist das elementweise Quadrat von d. Zuletzt kommt stdx::reduce(e) zum Einsatz. Dabei wird der Vektor e auf seine Summe reduziert.

Besonders interessant ist der Ausdruck const stdx::fixed_size_simd x([](int i) { return i; }). Durch ihn wird der SIMD-Vektor x mit 16 long-double-Werten von 0 bis 15 initialisiert. Das ist möglich, wenn die Hardware hinreichend modern ist und AVX-252 unterstützt, beispielsweise mit Intels Xeon-Phi- oder AMDs Zen-4-Architektur.

Ähnlich interessant ist die Zeile println("cos²(x) + sin²(x)", stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::sin(x), 2)). Sie berechnet cos²(x) + sin²(x) für jedes Element, was aufgrund der trigonometrischen Identität des Pythagoras für alle Elemente 1 ist. Es gilt, dass alle Funktionen in außer den speziellen mathematischen Funktionen für simd überladen sind. Dies sind zum Beispiel die grundlegenden Funktionen wie abs, min oder max. Aber auch zum Beispiel exponentielle, trigonometrische, hyperbolische, Potenz- oder Gamma-Funktionen lassen sich direkt auf SIMD Vektor anwenden.

Nun möchte ich noch auf die Breite des Datentyps simd genauer eingehen.

Breite von simd

Die Breite des Datentyps native_simd wird durch die Implementierung zur Compile-Zeit bestimmt. Im Gegensatz dazu gibt der Entwickler die Breite des Datentyps fixed_size_simd vor.

Das Klassen-Template simd besitzt folgende Deklaration:

template< class T, class Abi = simd_abi::compatible >
class simd;

Dabei steht T für den Elementtyp, der nicht bool sein kann. Durch den Abi-Tag wird die Anzahl der Elemente und deren Speicher bestimmt.

Zu diesem Klassen-Template gibt es zwei Aliase:

template< class T, int N >
using fixed_size_simd = std::experimental::simd>;
template< class T >
using native_simd = std::experimental::simd>;

Folgende ABI-Tags stehen zur Verfügung:

• scalar: Speicherung eines einzelnen Elements
• fixed_size: Speicherung einer bestimmten Anzahl von Elementen
• compatible: gewährleistet ABI-Kompatibilität
• native: am effizientesten
• max_fixed_size: maximale Anzahl von Elementen, die garantiert von fixed_size unterstützt werden

Wie geht’s weiter?

Nach diesem ersten Beispiel zu datenparallelen Typen möchte ich im nächsten Artikel genauer auf deren Funktionalität eingehen.

(rme)

Im vergangenen Jahr waren in Deutschland rund 1,52 Millionen Menschen in Informatik- sowie Informations- und Kommunikationstechnologieberufen beschäftigt. Dies entspricht einem Anstieg um vier Prozent gegenüber dem Vorjahr, wie die Bundesagentur für Arbeit in Nürnberg mitteilt.

Das Wachstum basiere vor allem auf einem Anstieg der sozialversicherungspflichtigen Beschäftigung, die seit dem Jahr 2014 um rund 70 Prozent beziehungsweise 463.000 Personen zugenommen habe. Ausländische Fachkräfte spielten dabei eine immer bedeutendere Rolle. Im Jahr 2024 hatten rund 165.000 Beschäftigte in IKT-Berufen keine deutsche Staatsangehörigkeit. Damit habe ihr Anteil bei 15 Prozent aller sozialversicherungspflichtig Beschäftigten in diesem Bereich gelegen.

Indien, Türkei, Russland

Besonders deutlich sei der Zuwachs bei Personen aus Indien, der Türkei, Russland, der Ukraine sowie aus den acht Haupt-Asylherkunftsländern. Insgesamt rund 15.000 der ausländischen IKT-Beschäftigten besaßen im Jahr 2024 eine dieser Staatsangehörigkeiten, vor allem aus dem Iran (5.000), Pakistan (4.000) und Syrien (3.000).

Trotz des Beschäftigungswachstums sei die Zahl der neu gemeldeten Stellen im Jahr 2024 auf rund 44.000 zurückgegangen, ein Minus von 24 Prozent im Vergleich zum Vorjahr. Gründe seien die konjunkturelle Schwäche sowie ein struktureller Wandel in der Branche.

Hoher Bedarf in Softwareentwicklung

Besonders in der Softwareentwicklung bestünden weiterhin Fachkräfteengpässe. „Berufe in der Informations- und Kommunikationstechnologie entwickeln sich rasant, was hohe Anpassungsfähigkeit und kontinuierliche Weiterbildung erfordert“, betonte die Vorstandsvorsitzende der Bundesagentur, Andrea Nahles. Insbesondere im Bereich der Künstlichen Intelligenz sei ein sehr dynamischer Fortschritt zu beobachten.

Nahles betont zudem die Bedeutung einer stärkeren Beteiligung von Frauen: Der Anteil weiblicher Beschäftigter in der IKT liegt derzeit bei nur 18 Prozent. Auch im Bereich Ausbildung und Studium wächst die Zahl der Nachwuchskräfte. So waren im Studienjahr 2023/2024 etwa 258.000 Studierende im Bereich Informatik eingeschrieben – ein Zuwachs von 42 Prozent seit 2013. Der Frauenanteil stieg leicht auf 22 Prozent.

(mho)

Der Zugriff auf nicht-öffentliche Mitglieder einer Klasse über eine Wrapper-Klasse („Accessor“), die [UnsafeAccessorAttribute] nutzt, wurde in .NET 8.0 eingeführt.

Nun funktioniert das auch mit generischen Parametern:

using System.Runtime.CompilerServices;
 
namespace NET9_Console.FCL90_UnsafeAccessor;
/// Der Zugriff auf nicht-öffentliche Mitglieder einer Klasse über eine Wrapper-Klasse, die [UnsafeAccessorAttribute] nutzt, wurde in .NET 8.0 eingeführt. Neu in .NET 9.0: Nun funktioniert dies auch mit generischen Parametern.
 
/// 

/// Eine Klasse mit zwei privaten Mitgliedern, die wir über UnsafeAccessorAttribute von Außen nutzen wollen
/// 
/// 
public class Printer
{
 private T _data = default;
 private void Print(PreTextType preText) { CUI.Green(preText.ToString()); Console.WriteLine(_data.ToString()); }
 public override string ToString()
 {
  return "Data=" + (_data?.ToString() ?? "(leer)");
 }
}
 
/// 

/// Accessor für Printer, um auf private Mitglieder zugreifen zu können
/// 
class PrinterAccessor
{
 [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_data")] // Zugriff auf das private Feld
 public extern static ref T GetSetPrivateField(Printer p);
 
 [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "Print")] // Zugriff auf die private Methode
 public extern static void CallPrivatePrint(Printer p, PreTextType preText);
}
 
/// 
class Client
{
 public void Run()
 {
  CUI.Demo(nameof(FCL90_UnsafeAccessor));
 
  CUI.H2("Erzeuge das Objekt mit den privaten Mitgliedern");
  Printer printer = new Printer();
  Console.WriteLine("Vorher:\n" + printer.ToString());
 
  // Zugriff auf das Objekt via Accessor
  CUI.H2("Setzen eines privaten Feldes");
  ref Consultant data = ref PrinterAccessor.GetSetPrivateField(printer);
  data = new Consultant() { ID = 42, FullName = "Dr. Holger Schwichtenberg", PersonalWebsite = "www.dotnet-doktor.de", Address = new Address() { City = "Essen" }, Languages = ["C#", "VB.NET", "JavaScript/TypeScript"] };
  CUI.Success("Wert für Private Field gesetzt!");
  Console.WriteLine("Kontrolle über Zugriff auf das öffentliche ToString():\n" + printer.ToString());
 
  // Methode aufrufen
  CUI.H2("Aufruf einer privaten Methode mit generischen Parametern: CallPrivatePrint()");
  PrinterAccessor.CallPrivatePrint(printer, "Sie werden beraten von:");
 }
}

(rme)