Скорость чтения csv с разных носителей

extern "C" __declspec(dllexport) LPXLOPER12  WINAPI FindInCSV(char *  arg1, char *  arg2, wchar_t *  arg3)
{
    LPXLOPER12 OperOut = new XLOPER12;
    OperOut->xltype = xltypeStr | xlbitDLLFree;
    OperOut->val.str = new XCHAR[32767 + 2]; //+1 под размер + 1 под нуль-терминатор
    OperOut->val.str[0] = 0;
    OperOut->val.str[1] = '\0';
    std::filebuf fb;
    if (fb.open(arg1, std::ios::in | std::ios::binary))
    {
        int x = 0;
        int lenStrOut = 0; //0й элемент - размер строки
        int lenArg3 = wcslen(arg3);
        bool overflow = false;
        std::string str;
        std::istream is(&fb);
        XCHAR* strTmp= OperOut->val.str + 1;
 
        while (is) 
        {
            std::getline(is, str);
            size_t found = str.find(arg2);
            if (found != std::string::npos)
            {
                x++;
                if (lenArg3 > 0 && x > 1)
                {
                    if (lenStrOut + lenArg3 > 32767) { overflow = true;  goto end_; }
                    wcscpy(strTmp + lenStrOut, arg3);
                    lenStrOut = lenStrOut + lenArg3;
 
                    if (lenStrOut + str.length() > 32767) { overflow = true;  goto end_; }
                    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str.c_str(), -1, strTmp + lenStrOut, str.length() + 1);
                    lenStrOut = lenStrOut + str.length();
                }
                else if (lenArg3 > 0)
                {
                    if (lenStrOut + str.length() > 32767) { overflow = true;  goto end_; }
                    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str.c_str(), -1, strTmp + lenStrOut, str.length() + 1);
                    lenStrOut = lenStrOut + str.length();
                }
                else
                {
                    if (lenStrOut + str.length() > 32767) { overflow = true;  goto end_; }
                    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, str.c_str(), -1, strTmp + lenStrOut, str.length() + 1);
                    lenStrOut = lenStrOut + str.length();
                    goto end_ ;
                }
            };
        }
    end_:
        if (overflow) {
            wcscpy(strTmp, L"Qverflow. Max char 32767\0");
            OperOut->val.str[0] = 24;
        }
        else
        {
            OperOut->val.str[0] = lenStrOut;
        }
        fb.close();
    }
    return OperOut;
}

// [URL="https://stackoverflow.com/questions/23468227/memory-usage-when-using-boostiostreamsmapped-file"]link[/URL]
//code here which uses boost iostream to mmap & then writes to the mapped file:
typedef unordered_map<int, string> work;
 
    int main()
    {
 
            work d;
            d[0] = "a";
 
            boost::iostreams::mapped_file_params  params;
            params.path = "map.dat";
            params.new_file_size = 1000000000;
            params.mode = (std::ios_base::out | std::ios_base::in);
            boost::iostreams::mapped_file  mf;
            mf.open(params);
            work* w = static_cast<work*>((void*)mf.data());
            w[0] = d;
            for(int i=1; i <1000000000 ;++i)
            {
                    w->insert(std::make_pair(i, "abcdef"));
            }
            mf.close();
 
    }

int FindInCSVansi(PCTSTR path, const char* findStr, bool multiLine, bool NO_BUFFERING)
{
const DWORD  nNumberOfBytesToRead = 33554432; //16777216;//8388608;//читаем в буфер байты
char* notAlignBuf = new char[nNumberOfBytesToRead + 4096]; //буфер
char* buf = notAlignBuf; //буфер
if (size_t(buf) % 4096) { buf += 4096 - (size_t(buf) % 4096); }//адрес принимающего буфера тоже должен быть выровнен по размеру сектора/страницы 
 
char* notAlignBufBufWork = new char[nNumberOfBytesToRead + 4096 + 1]; //буфер Рабочий
char* bufWork = notAlignBufBufWork; //буфер
if (size_t(bufWork) % 4096) { bufWork += 4096 - (size_t(bufWork) % 4096); }//адрес рабочего буфера тоже выровнял по размеру сектора/страницы  
 
bufWork[0] = '\0';//добавим нуль-терминатор
bufWork[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
char* find;// указатель для поиска
size_t strCount = 1; //счетчик строк
std::string strOut; //итоговая строка
DWORD  dwBytesReadWork;
DWORD findStatus = 0; //статус поиска
ULONGLONG ignoreOffset=0; //для расчета холостых циклов
bool ERR_HANDLE_EOF = false; //метка конца файла
 
// создаем события с автоматическим сбросом
HANDLE hEndRead = CreateEvent(NULL, FALSE, FALSE, NULL);// дескриптор события
if (hEndRead == NULL) { return GetLastError(); }
 
_ULARGE_INTEGER ui; //Представляет 64-разрядное целое число без знака обединяя два 32-х разрядных
ui.QuadPart = 0;
 
OVERLAPPED  ovl;   // структура управления асинхронным доступом к файлу// инициализируем структуру OVERLAPPED
ovl.Offset = 0;         // младшая часть смещения равна 0
ovl.OffsetHigh = 0;      // старшая часть смещения равна 0
ovl.hEvent = hEndRead;   // событие для оповещения завершения чтения
 
// открываем файл для чтения
HANDLE hFile = CreateFile(  // дескриптор файла
    path,   // имя файла
    GENERIC_READ,          // чтение из файла
    FILE_SHARE_READ,       // совместный доступ к файлу
    NULL,                  // защиты нет
    OPEN_EXISTING,         // открываем существующий файл
    FILE_FLAG_OVERLAPPED | (NO_BUFFERING ? FILE_FLAG_NO_BUFFERING : FILE_FLAG_RANDOM_ACCESS),// асинхронный ввод//отключаем системный буфер
    NULL                   // шаблона нет
);
// проверяем на успешное открытие
if (hFile == INVALID_HANDLE_VALUE)
{
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufBufWork;
    return -1;
}
// читаем данные из файла
for (;;)
{
    DWORD  dwBytesRead;
    DWORD  dwError;
    find = buf; //буфер
    // читаем одну запись
    if (!ReadFile(
        hFile,           // дескриптор файла
        buf,             // адрес буфера, куда читаем данные
        nNumberOfBytesToRead,// количество читаемых байтов
        &dwBytesRead,    // количество прочитанных байтов
        &ovl             // чтение асинхронное
    ))
    {
        switch (dwError = GetLastError())// решаем что делать с кодом ошибки
        {
            //эти ошибки смотрм после завершения асинхронной операции чтения, для возможности обработать рабочий буфер
        case ERROR_IO_PENDING: { break; }        // асинхронный ввод-вывод все еще происходит // сделаем кое-что пока он идет 
        case ERROR_HANDLE_EOF: { ERR_HANDLE_EOF = true; break; } // мы достигли конца файла читалкой ReadFile
        default: {goto return1; }// другие ошибки
        }
    }
    //работаем асинхронно, выполняем код, пока ждем чтение с диска//
    if (ui.QuadPart != ignoreOffset)//игнорируем первую итерацию и этерации прошедшие следующим буфером, когда нужно было вернутся в предыдущий буфер
    {
        bufWork[dwBytesReadWork] = '\0';//добавим нуль-терминатор
        find = bufWork; //новый буфер
    go_1:
        char* strStart = bufWork;
        char* strEnd = NULL;
 
        if (findStatus == 0)//goFind
        {
            find = strstr(find, findStr);
            if (find != NULL) //если нужная подстрока найдена
            {
 
                for (strStart = find; strStart >= bufWork; strStart--)
                {
                    if (*strStart == '\n') { break; } //если нашли начало строки
                }
                strStart++;
                if (ui.QuadPart == nNumberOfBytesToRead || strStart != bufWork)//если первый буфер или найдено начало строки
                {
                    strEnd = strchr(find, '\n');
                    if (strEnd != NULL) //если нашли конец строки
                    {
                        strOut = strOut + std::string(strStart, strEnd - strStart + 1);
                        if (!multiLine)
                        {
                            goto return0;
                        }
                        else//поиск в следующей строке начинаем с конца предыдущей
                        {
                            find = strEnd++;
                            findStatus = 0;
                            goto go_1;
                        }
                    }
                    else//если конец строки в следующем буфере или конец файла
                    {
                        strOut = strOut + std::string(strStart);
                        findStatus = 1;
                    }
                }
                else //если начало строки не найдено и это не первый буфер смотрим предыдущий буфер
                {
                    findStatus = 2;
                    ui.QuadPart -= nNumberOfBytesToRead * 3;
                    ignoreOffset = ui.QuadPart + nNumberOfBytesToRead;
                }
            } //если нужная подстрока найдена
        }
        else if (findStatus == 1)//goBuf
        {
            strEnd = strchr(find, '\n');
            if (strEnd != NULL) //если нашли конец строки
            {
                strOut = strOut + std::string(find, strEnd - find+1);
                findStatus = 0;
                if (!multiLine)
                {
                    goto return0;
                }
                else//поиск в следующей строке начинаем с конца предыдущей
                {
                    find = strEnd++;
                    findStatus = 0;
                    goto go_1;
                }
            }
            else//если конец строки в следующем буфере или конец файла
            {
                strOut = strOut + std::string(find);
            }
        }
        else if (findStatus == 2)//goBackBuf
        {
 
            for (strStart = bufWork + dwBytesReadWork; strStart >= bufWork; strStart--)
            {
                if (*strStart == '\n') { break; }//если нашли начало строки
            }
            strStart++;
            if (ui.QuadPart == nNumberOfBytesToRead || strStart != bufWork)//если первый буфер или найдено начало строки
            {
                find = strStart++;
                findStatus = 1;
                goto go_1;
            }
            else
            {
                ui.QuadPart -= nNumberOfBytesToRead * 3;//если начало строки не найдлено смотрим предыдущий буфер
                ignoreOffset = ui.QuadPart + nNumberOfBytesToRead;
            }
 
        }
    }
    if (ERR_HANDLE_EOF) { if (findStatus != 2) goto return0; }
    //работаем асинхронно, выполняем код, пока ждем чтение с диска//
 
    // ждем, пока завершится асинхронная операция чтения
    WaitForSingleObject(hEndRead, INFINITE);
 
    // проверим результат работы асинхронного чтения // если возникла проблема ... 
    if (!GetOverlappedResult(hFile, &ovl, &dwBytesRead, FALSE))
    {
        switch (dwError = GetLastError())// решаем что делать с кодом ошибки
        {
        case ERROR_HANDLE_EOF: 
        {
            if (findStatus != 2) goto return0; break;//если конец файла. но мы должны вернутся найти начало строки.
        }// мы достигли конца файла в ходе асинхронной операции
        default: {goto return1; }// другие ошибки
        }// конец процедуры switch (dwError = GetLastError())
    }
 
    //синхронно копируем данные из буфера в рабочий буфер, далее с ним работаем асинхронно
    memcpy(bufWork, buf, nNumberOfBytesToRead);
 
    // увеличиваем смещение в файле
    dwBytesReadWork = dwBytesRead;//кол-во считанных байт
    ui.QuadPart += nNumberOfBytesToRead; //добавляем смещение к указателю на файл
    ovl.Offset = ui.LowPart;// вносим смещение в младшее слово
    ovl.OffsetHigh = ui.HighPart;// вносим смещение в старшеее слово
}
 
return0:
// закрываем дескрипторы, освобождаем память
std::cout << "String Find " << strOut << std::endl;
CloseHandle(hFile);
CloseHandle(hEndRead);
delete[] notAlignBuf;
delete[] notAlignBufBufWork;
return 0;
return1:
CloseHandle(hFile);
CloseHandle(hEndRead);
delete[] notAlignBuf;
delete[] notAlignBufBufWork;
return -1;
}