Linguaggi di programmazione Sindh

Question

Negli ultimi due anni, ho fatto molta programmazione SIMD e la maggior parte delle volte mi sono affidato a funzioni intrinseche del compilatore (come quelle per la programmazione SSE) o all'assemblaggio di programmazione per arrivare a la roba davvero elegante. Tuttavia, finora non sono riuscito a trovare alcun linguaggio di programmazione con supporto integrato per SIMD.

Ora ovviamente ci sono i linguaggi shader come HLSL, Cg e GLSL che hanno il supporto nativo per questo tipo di cose, tuttavia sto cercando qualcosa che sia in grado di compilare almeno su SSE senza autovectorization ma con supporto integrato per operazioni vettoriali. Esiste una lingua simile?

Questo è un esempio di (parte di) uno shader Cg che fa i riflettori e in termini di sintassi questo è probabilmente il più vicino a quello che sto cercando.

float4 pixelfunction(
    output_vs IN, 
    uniform sampler2D texture : TEX0, 
    uniform sampler2D normals : TEX1, 
    uniform float3 light, 
    uniform float3 eye ) : COLOR
{
    float4 color    = tex2D( texture, IN.uv );
    float4 normal   = tex2D( normals, IN.uv ) * 2 - 1;

    float3 T = normalize(IN.T);
    float3 B = normalize(IN.B);

    float3 N = 
        normal.b * normalize(IN.normal) +
        normal.r * T +
        normal.g * B;

    float3 V = normalize(eye - IN.pos.xyz);
    float3 L = normalize(light - IN.pos);
    float3 H = normalize(L + V);

    float4 diffuse  = color * saturate( dot(N, L) );
    float4 specular = color * pow(saturate(dot(N, H)), 15);
    float falloff   = dot(L, normalize(light));

    return pow(falloff, 5) * (diffuse + specular);
}

Le cose che sarebbero un vero must in questa lingua sono:

• Operatori swizzle integrati
• Operazioni vettoriali (punto, croce, normalizza, saturi, rifletti eccetera)
• Supporto per tipi di dati personalizzati (strutture)
• Il branching dinamico sarebbe carino (per loop, se istruzioni)

Answer 1

Di recente Intel ha rilasciato ISPC che è esattamente quello che stavo cercando quando ho posto questa domanda. È un linguaggio che può essere collegato al normale codice C, ha e modello di esecuzione implicita e supporto per tutte le funzionalità menzionate nel post iniziale (operatori swizzle, branching, strutture di dati, operazioni vettoriali, shader like) e compilazioni per SSE2, SSE4, Istruzioni vettoriali AVX, AVX2 e Xeon Phi.

Answer 2

La tua scommessa migliore è probabilmente OpenCL. So che è stato principalmente ipotizzato come un modo per eseguire codice su GPU, ma i kernel OpenCL possono anche essere compilati ed eseguiti su CPU. OpenCL è sostanzialmente C con alcune restrizioni:

1. Nessun puntatore a funzione
2. Nessuna ricorsione

e un sacco di aggiunte. In particolare i tipi di vettori:

float4 x = float4(1.0f, 2.0f, 3.0f, 4.0f);
float4 y = float4(10.0f, 10.0f, 10.0f, 10.0f);

float4 z = y + x.s3210 // add the vector y with a swizzle of x that reverses the element order

Su un grande avvertimento è che il codice deve essere chiaramente sperabile, OpenCL non può richiamare librerie arbitrarie, ecc. Ma se i tuoi kernel di calcolo sono ragionevolmente indipendenti, in pratica ottieni un vettore C migliorato dove non ti serve usare intrinseci.

Qui è un riferimento rapido / cheatsheet con tutti le estensioni.

Answer 3

In realtà non è la lingua stessa, ma esiste una libreria per Mono ( Mono.Simd ) che esporrà i vettori a te e ottimizzerà le operazioni su di essi in SSE quando possibile:

Answer 4

È una libreria per C ++, piuttosto che integrata nel linguaggio, ma Eigen è piuttosto invisibile una volta che le tue variabili sono dichiarati.

Answer 5

Attualmente la soluzione migliore è farlo da solo creando un back-end per il frontend Cg open source che Nvidia ha rilasciato, ma mi piacerebbe risparmiarmi lo sforzo, quindi sono curioso di sapere se è stato fatto prima. Preferibilmente inizierei a usarlo subito.

Answer 6

Il linguaggio di programmazione D fornisce anche l'accesso a SIMD in modo simile a Mono.SIMD.

Answer 7

Questo sarebbe Fortran che stai cercando. Se la memoria serve anche i compilatori open source (g95, gfortran) trarranno vantaggio da SSE se è implementato sul tuo hardware.