Digitare il sistema per le prestazioni

Esistono sistemi di tipo (statico) che tentano di formalizzare le caratteristiche prestazionali dei programmi? Non riesco a trovare sembra trovare tali tentativi.

Poiché i sistemi di tipo sono (uno dei) strumenti più potenti nell'arsenale del programmatore per fare dichiarazioni sui programmi e poiché ci sono molti casi in cui le prestazioni sono fondamentali, non sembrerebbe inverosimile immaginare che fossero stati intrapresi tentativi di creare un sistema di tipi che tenti di fare almeno alcune dichiarazioni sulle caratteristiche di archiviazione e runtime dei programmi.

language-design

— Klaas van Schelven
fonte

Cosa direbbe il tuo sistema di tipi sulle prestazioni di if condition then expensive_operation else cheap_operation?

— svick,

So che ci sono stati sviluppi nell'uso dell'interpretazione astratta per inferire automaticamente la complessità del codice (e la terminazione) nel caso peggiore. Potrebbe interessarti ...

— Bakuriu,

Non del tutto correlato, ma comunque: kernelnewbies.org/FAQ/LikelyUnlikely Nel compilatore kernel / gcc Linux sono macro probabili / improbabili per ottimizzare determinati percorsi. Ad esempioif (likely(operation_went_fine)) { // Do something } else if (unlikely(error_occured)) { // Do something else }

— AmazingDreams,

Vengono in mente le parole chiave volatili e di registro in C.

— Mattnz,

Risposte:

Potresti immaginare un sistema di tipo abbastanza sofisticato da essere correlato a WCET o alla complessità del programma. Quindi, il problema è creare un analizzatore del tipo di suono (o un correttore), ovvero regole di digitazione, per renderlo possibile e implementarlo in modo sufficientemente efficiente da renderlo ragionevolmente utile.

La maggior parte dei sistemi di tipi sono abbastanza semplici da essere veloci da calcolare in pratica (almeno per la serie ragionevole di programmi che uno sviluppatore umano potrebbe scrivere manualmente).

Alcuni linguaggi di programmazione accademici (ad es. AGDA ) hanno sistemi di tipo molto sofisticati che sono completi di Turing, quindi il loro compilatore può richiedere un periodo di tempo (forse infinito).

(Se ho capito bene, il lavoro di dottorato di Jérémie Salvucci in corso al LIP6 di Parigi è abbastanza correlato alla tua domanda; gli ho inviato un'e-mail al riguardo; potresti cercare regioni e tipi ...).

Sii comunque consapevole del teorema di Rice e del problema di Halting . I sistemi di tipi potrebbero non essere sempre il proiettile d'argento che potresti desiderare (vedi il vecchio libretto senza proiettili d'argento ).

— Basile Starynkevitch
fonte

WCET è "Peggior tempo di esecuzione del caso" in questo contesto (nel caso qualcuno si

— chieda

Lingue tipicamente dipendenti come Agda, Coq, Epigram, Guru, Isabelle, ecc. "Risolvono" il problema di Halting, il teorema di Rice e gli amici non essendo Turing completi. O per costruzione (cioè non è semplicemente possibile scrivere un ciclo infinito / ricorsione non terminante), richiedendo che tutti i programmi debbano essere scritti in modo tale che il controllore di terminazione possa provare la fine, o richiedendo al programmatore di inviare un prova di terminazione controllabile dalla macchina.

— Jörg W Mittag,

Sembra eminentemente possibile creare un sistema di tipi che classifica le caratteristiche prestazionali dei tipi(es. "veloce / lento per accesso seriale," veloce / lento per accesso casuale "," memoria efficiente / inefficiente "). Tali tratti potrebbero essere tipi astratti inseriti nella gerarchia in modo tale che i tipi più concreti ereditati da essi. Tuttavia, le prestazioni di qualsiasi programma che utilizza questi tipi dipenderebbero dal modo in cui sono effettivamente utilizzate / accessibili. Affinché il sistema dei tipi faccia dichiarazioni sul programma stesso, l'uso di (accesso a) quei tipi dovrebbe essere rappresentato come tipi Ciò significherebbe rinunciare all'utilizzo di strutture di controllo integrate (ad es. Per / while loop) e invece utilizzare tipi che le implementano, quindi la gerarchia potrebbe avere un tipo di accesso seriale astratto e un elenco discendente-accesso-seriale, albero-seriale tipi di accesso e così via.L'efficienza di utilizzo potrebbe quindi essere espressa almeno in parte dalla combinazione e dall'applicazione di questi tipi tra loro.

In un linguaggio funzionale come Haskell - che comunque non ha quasi alcuna struttura di controllo - questo mi sembra abbastanza pratico e applicabile. In Java, tuttavia, un tale sistema sembra molto meno realizzabile (non tanto dall'implementazione quanto dall'applicabilità / affidabilità del risultato).

Haskell ci consente già di affermare definitivamente quanto di un programma è puro e fornisce modi per limitare determinate attività all'interno di scatole sigillate. Dato che il parallelismo / concorrenza in Haskell è implementato attraverso il sistema dei tipi , si potrebbe sostenere che fa già parte del modo in cui ci si trova (rispetto a ciò che si desidera). Al contrario, i linguaggi imperativi (anche quelli tipicamente statici come Java) offrono al programmatore molti, molti modi per sovvertire qualsiasi tentativo in tal senso.

— itsbruce
fonte