La storia di un hacker

La data è il 12/02/10. I giorni prima di Natale stanno scivolando via e ho praticamente colpito un blocco stradale importante come programmatore di Windows. Ho usato AQTime, ho provato assonnato, brillante e molto assonnato, e mentre parliamo, VTune si sta installando. Ho provato ad usare il profiler VS2008 ed è stato punito positivamente e spesso insensibile. Ho usato la tecnica di pausa casuale. Ho esaminato gli alberi di chiamata. Ho sparato tracce di funzione. Ma il triste fatto doloroso della questione è che l'app con cui sto lavorando è oltre un milione di righe di codice, con probabilmente un altro milione di righe di app di terze parti.

Ho bisogno di strumenti migliori. Ho letto gli altri argomenti. Ho provato ogni profiler elencato in ogni argomento. Deve semplicemente esserci qualcosa di meglio di queste opzioni schifose e costose, o ridicole quantità di lavoro per quasi nessun guadagno. Per complicare ulteriormente le cose, il nostro codice è fortemente intrecciato ed esegue una serie di loop di eventi Qt, alcuni dei quali sono così fragili da bloccarsi in presenza di strumenti pesanti a causa di ritardi temporali. Non chiedermi perché stiamo eseguendo più loop di eventi. Nessuno può dirmelo.

Esistono opzioni più simili a Valgrind in un ambiente Windows?
C'è qualcosa di meglio della lunga serie di strumenti rotti che ho già provato?
Esiste qualcosa progettato per integrarsi con Qt, forse con una utile visualizzazione degli eventi in coda?

Un elenco completo degli strumenti che ho provato, con quelli davvero utili in corsivo:

• AQTime: piuttosto buono! Ha qualche problema con la ricorsione profonda, ma il grafico della chiamata è corretto in questi casi e può essere usato per chiarire qualsiasi confusione che potresti avere. Non è uno strumento perfetto, ma vale la pena provarlo. Potrebbe soddisfare le tue esigenze, e sicuramente è stato abbastanza buono per me la maggior parte del tempo.
• Attacco Pausa casuale in modalità debug: informazioni insufficienti abbastanza spesso.
  Un buon strumento ma non una soluzione completa.
• Parallel Studios: l'opzione nucleare. Invadente, strano e follemente potente. Penso che dovresti iniziare la valutazione di 30 giorni e capire se è adatta. È anche dannatamente bello.
• AMD Codeanalyst: meraviglioso, facile da usare, molto soggetto a crash, ma penso che sia una cosa ambientale. Consiglierei di provarlo, in quanto è gratuito.
• Luke Stackwalker: funziona bene su piccoli progetti, sta un po 'cercando di farlo funzionare sui nostri. Alcuni buoni risultati però, e sicuramente sostituisce Sleepy per i miei compiti personali.
• PurifyPlus: nessun supporto per ambienti Win-x64, in particolare Windows 7. Altrimenti eccellente. Alcuni miei colleghi di altri dipartimenti lo giurano.
• Profilatore VS2008: produce output nell'intervallo 100+ in modalità traccia funzioni alla risoluzione richiesta. Tra i lati positivi, produce risultati solidi.
• GProf: richiede che GCC sia anche moderatamente efficace.
• VTune: il supporto W7 di VTune confina con i criminali. Altrimenti eccellente
• PIN: dovrei hackerare il mio strumento, quindi questa è una specie di ultima risorsa.
• Sleepy \ VerySleepy: utile per le app più piccole, ma non mi riesce qui.
• EasyProfiler: non male se non ti dispiace un po 'di codice iniettato manualmente per indicare dove strumenti.
• Valgrind: * solo nix, ma ottimo quando ci si trova in quell'ambiente.
• OProfile: solo Linux.
• Proffy: sparano a cavalli selvaggi.

Strumenti suggeriti che non ho provato:

• XPerf:
• GlowCode:
• DevPartner:

Note: ambiente Intel al momento. VS2008, boost librerie. Qt 4+. E il miserabile colonnello di tutti: integrazione Qt / MFC via trolltech.

---

Ora: quasi due settimane dopo, sembra che il mio problema sia stato risolto. Grazie a una varietà di strumenti, incluso quasi tutto nella lista e un paio di miei trucchi personali, abbiamo trovato i principali colli di bottiglia. Tuttavia, continuerò a testare, esplorare e provare nuovi profiler e nuove tecnologie. Perché? Perché lo devo a voi ragazzi, perché voi ragazzi rock. Rallenta un po 'la sequenza temporale, ma sono ancora molto entusiasta di continuare a provare nuovi strumenti.

Sinossi
Tra molti altri problemi, alcuni componenti sono stati recentemente passati al modello di threading errato, causando gravi blocchi a causa del fatto che il codice sottostante non è stato improvvisamente più multithread. Non posso dire altro perché viola la mia NDA, ma posso dirti che questo non sarebbe mai stato trovato da un'ispezione casuale o anche dalla normale revisione del codice. Senza profiler, calligrafi e pause casuali insieme, continueremmo a urlare la nostra furia per il bellissimo arco blu del cielo. Per fortuna, lavoro con alcuni dei migliori hacker che abbia mai incontrato, e ho accesso a un versetto fantastico pieno di strumenti fantastici e persone fantastiche.

Gentile gente, lo apprezzo moltissimo, e mi pento solo di non avere abbastanza rappresentante per premiare ognuno di voi con una generosità. Penso ancora che questa sia una domanda importante per ottenere una risposta migliore rispetto a quelle che abbiamo avuto finora su SO.

Di conseguenza, ogni settimana per le prossime tre settimane, metterò la taglia più grande che posso permettermi e assegnandola alla risposta con lo strumento più bello che penso non sia conoscenza comune. Speriamo che dopo tre settimane avremo accumulato un profilo definitivo dei profiler, se perdonerai la mia punizione.

Take-away
Usa un profiler. Sono abbastanza buoni per Ritchie, Kernighan, Bentley e Knuth. Non mi interessa chi pensi di essere. Usa un profiler. Se quello che hai non funziona, trovane un altro. Se non riesci a trovarne uno, codificane uno. Se non riesci a codificarne uno, o è un piccolo problema, o sei semplicemente bloccato, usa una pausa casuale. Se tutto il resto fallisce, assumere alcuni studenti laureati per sbattere un profiler.

---

Una visione più lunga
Quindi, ho pensato che sarebbe stato bello scrivere un po 'di una retrospettiva. Ho scelto di lavorare ampiamente con Parallel Studios, in parte perché in realtà è basato sullo strumento PIN. Avendo avuto rapporti accademici con alcuni dei ricercatori coinvolti, ho sentito che questo era probabilmente un segno di qualità. Per fortuna, avevo ragione. Mentre la GUI è un po 'terribile, ho trovato IPS incredibilmente utile, anche se non posso consigliarlo comodamente a tutti. Criticamente, non esiste un modo ovvio per ottenere il numero di hit a livello di linea, cosa fornita da AQT e da un certo numero di altri profiler, e ho trovato molto utile per esaminare, tra le altre cose, il tasso di selezione delle filiali. In rete, mi è piaciuto anche usare AQTime e ho trovato il loro supporto molto reattivo. Ancora una volta, devo qualificare la mia raccomandazione: Molte delle loro funzioni non funzionano così bene, e alcune di esse sono decisamente soggette a crash su Win7x64. Anche XPerf ha funzionato egregiamente, ma è stranamente lento per i dettagli di campionamento richiesti per ottenere buone letture su alcuni tipi di applicazioni.

In questo momento, dovrei dire che non penso che ci sia un'opzione definitiva per la profilazione del codice C ++ in un ambiente W7x64, ma ci sono certamente opzioni che semplicemente non riescono a eseguire alcun servizio utile.

Primo:

I profili di campionamento del tempo sono più robusti dei profili di campionamento della CPU. Non ho molta familiarità con gli strumenti di sviluppo di Windows, quindi non posso dire quali sono quali. La maggior parte dei profiler è il campionamento della CPU.

Un profiler di campionamento della CPU acquisisce una traccia dello stack ogni N istruzioni.
Questa tecnica rivelerà parti del codice associate alla CPU. Il che è fantastico se questo è il collo di bottiglia nella tua applicazione. Non eccezionale se i thread delle tue applicazioni trascorrono la maggior parte del loro tempo a combattere per un mutex.

Un profiler di campionamento temporale acquisisce una traccia dello stack ogni N microsecondi.
Questa tecnica si concentrerà sul codice "lento" . Se la causa è legata alla CPU, blocca le connessioni IO, il mutex o la cache che interrompe sezioni di codice. In breve, qualunque parte del codice stia rallentando la tua applicazione sarà eccezionale.

Quindi, se possibile, utilizzare un profiler di campionamento temporale, specialmente quando si profila il codice thread.

Secondo:

I profiler di campionamento generano una serie di dati. I dati sono estremamente utili, ma spesso ci sono troppi per essere facilmente utili. Un visualizzatore di dati di profilo aiuta enormemente qui. Lo strumento migliore che ho trovato per la visualizzazione dei dati del profilo è gprof2dot . Non lasciarti ingannare dal nome, gestisce tutti i tipi di output del profiler di campionamento (AQtime, Sleepy, XPerf, ecc.). Una volta che la visualizzazione ha evidenziato le funzioni offensive, tornare ai dati del profilo non elaborato per ottenere migliori suggerimenti su quale sia la vera causa.

Lo strumento gprof2dot genera una descrizione del grafico a punti che viene quindi inserita in uno strumento graphviz . L'output è fondamentalmente un callgraph con funzioni codificate a colori in base al loro impatto sull'applicazione.

Alcuni suggerimenti per ottenere gprof2dot per generare un buon output.

• Uso un valore --skewdi 0,001 nei miei grafici in modo da poter vedere facilmente i percorsi degli hot code. Altrimenti int main()domina il grafico.
• Se stai facendo qualcosa di folle con i modelli C ++ probabilmente vorrai aggiungere --strip. Questo è particolarmente vero con Boost.
• Uso OProfile per generare i miei dati di campionamento. Per ottenere un buon output ho bisogno di configurarlo per caricare i simboli di debug dalle mie librerie di sistema e di terze parti. Assicurati di fare lo stesso, altrimenti vedrai che CRT impiega il 20% del tempo della tua applicazione quando quello che sta realmente succedendo mallocè distruggere l'heap e consumare il 15%.

Che cosa è successo quando hai provato una pausa casuale? Lo uso sempre su un'app monster. Hai detto che non ha fornito informazioni sufficienti e hai suggerito di aver bisogno di una risoluzione elevata. A volte le persone hanno bisogno di un piccolo aiuto per capire come usarlo.

Quello che faccio, sotto VS, è configurare il display dello stack in modo che non mi mostri gli argomenti della funzione, perché ciò rende il display dello stack totalmente illeggibile, IMO.

Quindi prendo circa 10 campioni premendo "pausa" durante il tempo che mi fa aspettare . Uso ^ A, ^ C e ^ V per copiarli nel blocco note, per riferimento. Poi studio ciascuno di essi, per cercare di capire cosa stava provando a realizzare in quel momento.

Se stava provando a realizzare qualcosa su 2 o più campioni, e quella cosa non è strettamente necessaria, allora ho trovato un problema dal vivo e so più o meno quanto aggiustarlo salverà.

Ci sono cose che non si ha realmente bisogno di sapere, come percentuali precise non sono importanti, e ciò che avviene codice di terze parti al suo interno non è importante, perché non si può fare nulla su quelli . Quello che puoi fare è il ricco set di punti di chiamata nel codice che puoi modificare visualizzato su ogni campione dello stack. Questo è il tuo terreno di caccia felice.

Esempi dei tipi di cose che trovo:

• Durante l'avvio, può essere profondo circa 30 strati, nel processo di tentativo di estrarre stringhe di caratteri internazionalizzate dalle risorse DLL. Se vengono esaminate le stringhe effettive, si può facilmente scoprire che le stringhe non hanno davvero bisogno di essere internazionalizzate, come se fossero stringhe che l'utente non vede realmente.

• Durante il normale utilizzo, alcuni codici impostano innocentemente una proprietà modificata in alcuni oggetti. Tale oggetto proviene da una superclasse che cattura il cambiamento e innesca le notifiche che si propagano nell'intera struttura dei dati, manipolando l'interfaccia utente, creando e distruggendo gli oggetti in modi difficili da prevedere. Questo può accadere molto: le conseguenze inattese delle notifiche.

• Compilare un foglio di lavoro riga per riga, cella per cella. Risulta che se costruisci la riga tutta in una volta, da una matrice di valori, è molto più veloce.

PS Se sei multi-thread, quando lo metti in pausa, tutti i thread vengono messi in pausa. Dai un'occhiata allo stack di chiamate di ogni thread. Le probabilità sono, solo uno di loro è il vero colpevole, e gli altri sono inattivi.

Ho avuto un certo successo con AMD CodeAnalyst .

Hai una funzione MFC OnIdle? In passato avevo un'app quasi in tempo reale che dovevo correggere che stava lasciando cadere i pacchetti seriali quando impostato a una velocità di 19,2 K che un PentiumD avrebbe dovuto essere in grado di tenere il passo. La funzione OnIdle era ciò che stava uccidendo le cose. Non sono sicuro che QT abbia questo concetto, ma verificherei anche quello.

Riguardo al VS Profiler - se sta generando file così grandi, forse il tuo intervallo di campionamento è troppo frequente? Prova ad abbassarlo, poiché probabilmente avrai comunque abbastanza campioni.

E idealmente, assicurati di non raccogliere campioni fino a quando non stai effettivamente esercitando l'area problematica. Quindi inizia con la raccolta in pausa, fai in modo che il tuo programma esegua la sua "attività lenta", quindi avvia la raccolta. Hai solo bisogno di un massimo di 20 secondi di raccolta. Ferma la raccolta dopo questo.

Ciò dovrebbe aiutare a ridurre le dimensioni del file di esempio e acquisire solo ciò che è necessario per l'analisi.

Ho usato con successo PurifyPlus per Windows. Sebbene non sia economico, IBM fornisce una versione di prova leggermente paralizzata. Tutto ciò che serve per la profilazione con quantificazione sono i file pdb e il collegamento con / FIXED: NO. Unico inconveniente: nessun supporto per Win7 / 64.

Easyprofiler - Non l'ho ancora visto menzionato qui, quindi non sono sicuro se l'hai già visto. Adotta un approccio leggermente diverso nel modo in cui raccoglie i dati metrici. Uno svantaggio nell'uso del suo approccio al profilo in fase di compilazione è che devi apportare modifiche alla base di codice. Quindi dovrai avere un'idea di dove potrebbe essere il lento e inserire lì il codice di profilazione.

Seguendo i tuoi ultimi commenti, sembra che tu stia almeno facendo qualche passo avanti. Forse questo strumento potrebbe fornirti alcune metriche utili per te. Se non altro ha alcuni grafici e immagini davvero purdy: P

Altri due suggerimenti per gli strumenti.

Luke Stackwalker ha un nome carino (anche se sta provando un po 'duro per i miei gusti), non ti costerà nulla e otterrai il codice sorgente. Sostiene di supportare anche programmi multi-thread. Quindi vale sicuramente la pena fare un giro.

http://lukestackwalker.sourceforge.net/

Anche Glowcode, che mi ha fatto notare come vale la pena usare:

http://www.glowcode.com/

Sfortunatamente non ho fatto alcun lavoro sul PC per un po ', quindi non ho provato nessuno di questi. Spero che i suggerimenti siano di aiuto comunque.

Acquista XPerf

Questo è un profiler gratuito, non invasivo ed estensibile offerto dalla SM. È stato sviluppato da Microsoft per profilare Windows.

Se sospetti del ciclo degli eventi, potresti ignorare QCoreApplication :: notification () e la profilazione manuale dosome (una o due mappe di mittenti / eventi per conteggi / tempo)?

Sto pensando che prima registri la frequenza dei tipi di evento, quindi esamini più attentamente quegli eventi (quale oggetto lo invia, cosa contiene, ecc.). I segnali tra i thread sono messi in coda in modo implicito, quindi finiscono nel ciclo degli eventi (ovviamente anche le connessioni in coda esplicite).

Lo abbiamo fatto per intercettare e segnalare eccezioni nei nostri gestori di eventi, quindi in realtà ogni evento passa lì.

Solo un'idea

Modifica: vedo ora che hai menzionato questo nel tuo primo post. Accidenti, non avrei mai pensato di essere quel ragazzo.

Puoi usare Pin per strumentare il tuo codice con una granularità più fine. Penso che Pin ti permetterebbe di creare uno strumento per contare quante volte si entra in una funzione o quante lancette si trascorrono lì, emulando all'incirca qualcosa come VTune o CodeAnalyst. Quindi è possibile eliminare le funzioni che vengono strumentate fino a quando i problemi di temporizzazione scompaiono.

Posso dirti cosa uso ogni giorno.

a) Analista del codice AMD

• È facile e ti darà una rapida panoramica di ciò che sta accadendo. Sarà ok per la maggior parte del tempo.
• Con le CPU AMD, ti dirà informazioni sulla pipeline della cpu, ma ti serve solo se hai loop pesanti, come nei motori grafici, nei codec video, ecc.

b) VTune.

• È molto ben integrato in vs2008

• dopo aver conosciuto gli hotspot, è necessario campionare non solo il tempo, ma altre cose come i mancati cache e l'utilizzo della memoria. Questo è molto importante . Imposta una sessione di campionamento e modifica le proprietà. Ho sempre campionato per tempo, memoria lettura / scrittura e cache mancate (tre diverse esecuzioni)

Ma oltre allo strumento, è necessario acquisire esperienza con la profilazione. E questo significa capire come funziona la CPU / Memoria / PCI ... quindi, questa è la mia terza opzione

c) Test unitari

Questo è molto importante se stai sviluppando una grande applicazione che richiede prestazioni enormi. Se non riesci a dividere l'app in alcuni pezzi, sarà difficile tenere traccia dell'utilizzo della cpu. Non testare tutti i casi e le classi, ma ho esecuzioni codificate e file di input con caratteristiche importanti.

Il mio consiglio è di utilizzare il campionamento casuale in diversi piccoli test e provare a standardizzare una strategia di profilo.

Uso xperf / ETW per tutte le mie esigenze di profilazione. Ha una ripida curva di apprendimento ma è incredibilmente potente. Se stai profilando su Windows, devi conoscere xperf. Uso spesso questo profiler per trovare problemi di prestazioni nel mio codice e nel codice di altre persone.

Nella configurazione che lo uso:

• xperf prende campioni di CPU da ogni core che esegue codice ogni ms. La frequenza di campionamento può essere aumentata a 8 KHz e i campioni includono la modalità utente e il codice del kernel. Ciò consente di scoprire cosa sta facendo un thread mentre è in esecuzione
• xperf registra ogni switch di contesto (consentendo una ricostruzione perfetta di quanto tempo impiega ogni thread), oltre a stack di chiamate per quando i thread vengono scambiati, oltre a stack di chiamate per quale thread ha preparato un altro thread, consentendo di tracciare le catene di attesa e scoprire perché un thread non sta correndo
• xperf registra tutti gli I / O dei file da tutti i processi
• xperf registra tutti gli I / O del disco da tutti i processi
• xperf registra quale finestra è attiva, la frequenza della CPU, lo stato di alimentazione della CPU, i ritardi dell'interfaccia utente, ecc.
• xperf può anche registrare tutte le allocazioni di heap da un processo, tutte le allocazioni virtuali da tutti i processi e molto altro.

Sono molti i dati, tutti su una timeline, per tutti i processi. Nessun altro profiler su Windows può farlo.

Ho ampiamente blog su come usare xperf / ETW. Questi post sul blog e alcuni video di formazione di qualità professionale sono disponibili qui: http://randomascii.wordpress.com/2014/08/08/19/etw-training-videos-available-now/

Se vuoi scoprire cosa potrebbe succedere se non usi xperf leggi questi post sul blog: http://randomascii.wordpress.com/category/investigative-reporting/ Questi sono racconti di problemi di prestazioni che ho trovato nel codice di altre persone , che avrebbe dovuto essere trovato dagli sviluppatori. Ciò include il caricamento di mshtml.dll nel compilatore VC ++, una negazione del servizio nei file di ricerca di VC ++, la limitazione termica in un numero sorprendente di macchine dei clienti, un singolo passo lento in Visual Studio, un'allocazione di 4 GB in un hard- driver del disco, un bug delle prestazioni di PowerPoint e altro ancora.

Ho appena finito la prima versione utilizzabile di CxxProf , una libreria portatile di profilatura con strumenti manuali per C ++.

Raggiunge i seguenti obiettivi:

• Facile integrazione
• Rimuovi facilmente la lib durante la compilazione
• Rimuovi facilmente la lib durante il runtime
• Supporto per applicazioni multithread
• Supporto per sistemi distribuiti
• Impatto minimo

Questi punti sono stati strappati dal wiki del progetto , dai un'occhiata qui per maggiori dettagli.

Disclaimer: sono lo sviluppatore principale di CxxProf

Giusto per buttarlo fuori, anche se non è un profiler completo: se tutto ciò che stai cercando sono i loop di eventi che richiedono molto tempo per elaborare un evento, uno strumento ad hoc è una questione semplice in Qt. Tale approccio potrebbe essere facilmente ampliato per tenere traccia di quanto tempo ha impiegato ogni evento a elaborare, quali sono stati quegli eventi e così via. Non è un profiler universale, ma incentrato sul ciclo degli eventi.

In Qt, tutte le chiamate di slot di segnale cross-thread vengono inviate tramite il loop degli eventi, così come i timer, le notifiche della porta di rete e seriale e tutte le interazioni dell'utente. Pertanto, osservare i loop degli eventi è un grande passo verso la comprensione di dove l'applicazione sta trascorrendo il suo tempo.

DevPartner, originariamente sviluppato da NuMega e ora distribuito da MicroFocus, una volta era la soluzione di scelta per la profilazione e l'analisi del codice (ad esempio perdite di memoria e risorse). Non l'ho provato di recente, quindi non posso assicurarti che ti aiuterà; ma una volta ho avuto ottimi risultati, quindi questa è un'alternativa che considero reinstallare nel nostro processo di qualità del codice (forniscono una prova di 14 giorni)

anche se il tuo sistema operativo è win7, il programma non può essere eseguito in xp? che ne dici di profilarlo sotto xp e il risultato dovrebbe essere un suggerimento per win7.

Ci sono molti profiler elencati qui e ne ho provati alcuni da solo - tuttavia ho finito per scrivere il mio basato su questo:

http://code.google.com/p/high-performance-cplusplus-profiler/

Ovviamente richiede che modifichi la base di codice, ma è perfetto per restringere i colli di bottiglia, dovrebbe funzionare su tutti gli x86 (potrebbe essere un problema con le scatole multi-core, cioè usa rdtsc, tuttavia - questo è puramente per un tempismo indicativo - quindi trovo che sia sufficiente per le mie esigenze ..)

Uso il profiler Orbit, facile, open source e potente! https://orbitprofiler.com/