Come posso aumentare le prestazioni su questo codice MFC?

StackOverflow https://stackoverflow.com/questions/4519985

Domanda

I condurre una ricerca di file e non v'è elenco di eccezioni per le directory, il problema è sotto il codice in modo ricorsivo itera attraverso tutti i file sui dischi rigidi. Funziona ma è lento. Pertanto, ho bisogno di aiuto per ottimizzare le prestazioni. Grazie in anticipo. 

CFileFind finder;

    // build a string with wildcards
    CString strWildcard(directory);
    strWildcard += _T("\\*.*");

    // start working for files
    BOOL bWorking = finder.FindFile(strWildcard);

    while (bWorking)
    {
        bWorking = finder.FindNextFile();

        if (finder.IsDots())
            continue;

        // if it's a directory, recursively search it

        if (finder.IsDirectory())
        {
            CString str = finder.GetFilePath();
            if(NULL == m_searchExceptions.Find(str)){
                _recursiveSearch(str);
            }
            else{
                continue;
            }
        }
        //basic comparison, can be replaced by strategy pattern if complicated comparsion required (e.g. REGEX)
        if(0 == finder.GetFileName().CompareNoCase(m_searchPattern)){
            if(m_currentSearchResults.Find(finder.GetFilePath()) == NULL){
                m_currentSearchResults.AddHead(finder.GetFilePath());       
            }
        }
    }
È stato utile?

Soluzione

Non credo che si sta andando ad essere in grado di ottimizzare le prestazioni qui. Stai andando a spendere 80 +% del vostro tempo all'interno FindFirstFile e FindNextFile qui (finestre chiamate API) Non importa quello che fai in termini di ottimizzazione da parte vostra.

ho fatto una domanda simile già e devono ancora per ottenere una risposta.

Altri suggerimenti

Sembra che il tuo m_currentSearchResults è una lista, e ogni volta che si trova un nome di file si guarda in su, se è già nella lista. Nel caso in cui hai un sacco di file trovati (centinaia dicono), questo può diventare un collo di bottiglia in quanto ha O(N^2) complessità. Se questo è il caso, è consigliabile utilizzare un CMap, invece, come ti dà O(log N) ricerca (un insieme sarebbe ancora più appropriato di una mappa, ma non hanno questo in MFC, ma si potrebbe anche usare std::set della libreria standard, invece).

Come lento? Hai il profilo it? Se siete alla ricerca di file in modo ricorsivo sul disco rigido è estremamente probabile che sei I / O bound e non c'è niente che puoi fare a corto di ottenere più veloce hardware di archiviazione (come a stato solido).

Stai facendo una ricerca generale di un file. Ci sono un milione di prodotti là fuori che fanno questo bene, e tutti usano l'indicizzazione come un'ottimizzazione. L'anello debole qui è sicuramente il disco, non il codice. Confrontando 1.000.000 stringhe ci vorrà pochissimo tempo rispetto al tempo necessario per enumerare 1.000.000 file sul disco.

Ci sono due questioni fondamentali sulle prestazioni qui: accesso al disco rigido e la directory traversal. Sia voi che possono in grado di ottimizzare il.

Disco rigido Ottimizzazione

Un disco rigido a riposo tende a rimanere a riposo. Un cilindro di filatura piace tenere filatura. Così ha detto, i colli di bottiglia di accesso al disco rigido stanno iniziando in su, tempo di ricerca e di tempo di lettura. Ridurre la quantità di accessi e di aumentare la quantità di dati per lettura aumenterà le prestazioni.

Accesso alla memoria è più veloce di accesso al disco rigido. Così trasportare grandi quantità di dati in memoria, quindi cercare di memoria.

Ottimizzare Ricerca directory.

Immaginate, se volete, un albero di "pagine". Ogni nodo nell'albero è una directory di zero o più directory o file. Purtroppo, nella maggior parte OS, questa struttura dati non è ottimizzato per la ricerca efficiente.

La situazione ideale è quella di raggio in tutte le directory rilevanti in memoria per poi cercare (in memoria). Una volta che la posizione del file è noto, l'accesso casuale ai file è relativamente veloce. Il problema è ridurre il tempo di ricerca da solo leggendo le directory pertinenti; vale a dire la riduzione del numero di directory irrilevante letture.

La maggior parte delle applicazioni che eseguono la ricerca di file su un disco rigido leggere l'unità e creare la propria struttura dati ottimizzata (s). Questo potrebbe non essere ottimale per enormi dischi rigidi con quantità enormouse di file o casi di alcune ricerche di file.

Se si può, dire al sistema operativo per mantenere il maggior numero di directory nella memoria possibile.

Performance Migliorare: Ridurre le altre applicazioni

.

Per alcune applicazioni, il tempo di prestazioni percepite dipende da altre applicazioni in esecuzione allo stesso tempo. Esecuzione di un compilatore e una ricerca su Internet in concomitanza rallenterà la maggior parte delle altre applicazioni. Quindi provare a eliminare le altre applicazioni che non sono necessari l'esecuzione in concomitanza con la vostra. Inoltre, investendo rasing la priorità della vostra applicazione.

1 per il profilo in primo luogo per essere sicuri. Inoltre, questo mi sembra un problema che potrebbe anche essere risolto utilizzando il Task Parallel Biblioteca - lanciare un compito, come si vede ogni directory, e utilizzare tutte quelle core della CPU -

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top