Скорость чтения 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;
}

#include <string>
#include <vector>
#include <fstream>
#include <ctime>
#include <iostream>
#include <exception>
#include <stdio.h>
 
#include <windows.h>
 
#define LOG(v) std::cout << #v << " = " << v << "\n";
 
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;    // мы достигли конца файла читалкой ReadFile
                        break;
                    }
                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;
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufBufWork;
    return 0;
return1:
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufBufWork;
    return -1;
}
 
const char* const NAMEFILE = "N1GB.txt";
 
///----------------------------------------------------------------------------|
/// Генератор файла большого размера.
///----------------------------------------------------------------------------:
void generator_testfile()
{   std::ifstream inf(NAMEFILE);
    if(inf.is_open())
    {   inf.close();
        std::cout << "file exist...\n\n";
        return;
    }
    inf.close();
    
    std::cout << "generator_testfile() work now...\n\n";
    std::ofstream f(NAMEFILE);
 
    const int N1GB = 1024*1024*4;
    const char* s =
        "qwerty1234567890qwerty1234567890qwerty1234567890qwerty1234567";
 
    for    (int i = 0; i < N1GB; i++)
    {   f << s << s << s << s << "\n";
    }
    f << "........................ASD123FGH456.........................\n";
    f.close();
}
 
int main()
{   setlocale(0, "");
    generator_testfile();
 
    clock_t t1;
 
    {   ///-------------------------------------|
        /// bedvit                              |
        ///-------------------------------------:
        std::cout << "1: ";/////////////////////////////////////////////////---1
        t1 = clock();
        int        x;
        if(x = FindInCSVansi("N1GB.txt", "ASD123FGH456", 0, 0))
        {
        }
        printf("bedvit                  : Time = %f\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    {   ///-------------------------------------|
        /// bedvit                              |
        ///-------------------------------------:
        std::cout << "2: ...\n\n";//////////////////////////////////////////---2
    }
 
    {   std::cout << "3: ";////////////////////////////////////////////////---3!
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        is.seekg (0, std::ios::end);
        size_t size = is.tellg()+1;
        is.seekg (0, std::ios::beg);
        
        char* p = new char[size];
        std::string s("ASD123FGH456");
        while (is)
        {   is.read(p, size);
 
            std::string str(std::move(p));
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: " << std::endl;
            };
        }
        printf("   read + Find             : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
        delete[] p;
    }
 
    {   std::cout << "4: ";/////////////////////////////////////////////////---4
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
 
        is.seekg (0, std::ios::end);
        size_t size = is.tellg();
        is.seekg (0, std::ios::beg);
 
        char* p = new char[size];
        while (is)
        {   is.read(p, size);
        }
        printf("read(без поиска)        : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
        delete[] p;
    }
 
    {   ///-------------------------------------|
        /// Небольшая школьная оптимизация!     |
        ///-------------------------------------:
        std::cout << "5: ";/////////////////////////////////////////////////---5
        t1 = clock();
        std::ifstream is(NAMEFILE);
        std::string str;
        str.reserve(1024);
        std::string s("ASD123FGH456");
        while(is)
        {   std::getline(is, str);
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: " << std::endl;
            };
        }
        printf("   getline + reserve(1024) : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
    
    {   std::cout << "6: ";/////////////////////////////////////////////////---6
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        size_t size = 64000000;
        std::vector<char> v(size);
        
        std::string s("ASD123FGH456");
        std::streamoff offset = -s.size();
        
        while (is)
        {   is.read(&v[0], size);
            is.seekg (offset, std::ios::cur);
            
            std::string str(std::move(&v[0]));
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: ";
                std::cout << str.substr(found, s.size()) << std::endl;
            };
        }
        printf("   read + Find + seekg     : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
    
    {   std::cout << "7: ";/////////////////////////////////////////////////---7
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        size_t size = 64000000;
        std::string str; str.assign(size, ' ');
        
        std::string s("ASD123FGH456");
        std::streamoff offset = -s.size();
        
        while (is)
        {   is.read((char*)str.data(), size);
            is.seekg (offset, std::ios::cur);
            
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: ";
                std::cout << str.substr(found, s.size()) << std::endl;
            };
        }
        printf("   read + Find + seekg     : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
 
    std::cout << "\n\n";
    system("pause");
    return 0;
}

#include <string>
#include <vector>
#include <fstream>
#include <ctime>
#include <iostream>
#include <exception>
#include <stdio.h>
 
#include <windows.h>
 
#define LOG(v) std::cout << #v << " = " << v << "\n";
 
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;    // мы достигли конца файла читалкой ReadFile
                        break;
                    }
                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;
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufBufWork;
    return 0;
return1:
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufBufWork;
    return -1;
}
 
const char* const NAMEFILE = "N1GB.txt";
 
///--------------------------------------|
/// Лимит на максимальный размер строки. |
///--------------------------------------:
size_t MAXSTR = 1024;
 
///----------------------------------------------------------------------------|
/// Генератор файла большого размера.
///----------------------------------------------------------------------------:
void generator_testfile()
{   std::ifstream inf(NAMEFILE);
    if(inf.is_open())
    {   inf.close();
        std::cout << "file exist...\n\n";
        return;
    }
    inf.close();
    
    std::cout << "generator_testfile() work now...\n\n";
    std::ofstream f(NAMEFILE);
 
    const int N1GB = 1024*1024*4;
    std::string s =
        "qwerty1234567890qwerty1234567890qwerty1234567890qwerty1234567";
    MAXSTR = 4 * s.size() + 1;
 
    for    (int i = 0; i < N1GB; i++)
    {   f << s << s << s << s << "\n";
    }
    f << "1.......................ASD123FGH456........................2\n";
    f.close();
}
 
int main()
{   setlocale(0, "");
    generator_testfile();
 
    clock_t t1;
 
    {   ///-------------------------------------|
        /// bedvit                              |
        ///-------------------------------------:
        std::cout << "1: ";/////////////////////////////////////////////////---1
        t1 = clock();
        int        x;
        if(x = FindInCSVansi("N1GB.txt", "ASD123FGH456", 0, 0))
        {
        }
        printf("bedvit                  : Time = %f\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    {   ///-------------------------------------|
        /// bedvit                              |
        ///-------------------------------------:
        std::cout << "2: ...\n\n";//////////////////////////////////////////---2
    }
 
    {   std::cout << "3: ";////////////////////////////////////////////////---3!
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        is.seekg (0, std::ios::end);
        size_t size = is.tellg()+1;
        is.seekg (0, std::ios::beg);
        
        char* p = new char[size];
        std::string s("ASD123FGH456");
        while (is)
        {   is.read(p, size);
 
            std::string str(std::move(p));
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: " << std::endl;
            };
        }
        printf("   read + Find             : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
        delete[] p;
    }
 
    {   std::cout << "4: ";/////////////////////////////////////////////////---4
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
 
        is.seekg (0, std::ios::end);
        size_t size = is.tellg();
        is.seekg (0, std::ios::beg);
 
        char* p = new char[size];
        while (is)
        {   is.read(p, size);
        }
        printf("read(без поиска)        : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
        delete[] p;
    }
 
    {   ///-------------------------------------|
        /// Небольшая школьная оптимизация!     |
        ///-------------------------------------:
        std::cout << "5: ";/////////////////////////////////////////////////---5
        t1 = clock();
        std::ifstream is(NAMEFILE);
        std::string str;
        str.reserve(1024);
        std::string s("ASD123FGH456");
        while(is)
        {   std::getline(is, str);
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: " << std::endl;
            };
        }
        printf("   getline + reserve(1024) : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
    
    {   std::cout << "6: ";/////////////////////////////////////////////////---6
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        size_t size = 64000000;
        std::vector<char> v(size);
        
        std::string s("ASD123FGH456");
        std::streamoff offset = -s.size();
        
        while (is)
        {   is.read(&v[0], size);
            is.seekg (offset, std::ios::cur);
            
            std::string str(std::move(&v[0]));
            size_t found = str.find(s);
            
            if (found != std::string::npos)
            {   std::cout << "Find OK: ";
            
                if     (size - found < MAXSTR) // +
                {   is.seekg (MAXSTR-size, std::ios::cur);
                    is.read(&v[0], size);
                }
                else if(size - found < size - MAXSTR) // -
                {   is.seekg (-MAXSTR-size, std::ios::cur);
                    is.read(&v[0], size);
                }
                str = std::string(std::move(&v[0]));
            
                size_t s1 = str.rfind('\n', found);
                size_t s2 = str.find ('\n', found);
                std::cout << str.substr(s1, s2-s1) << std::endl;
            };
        }
        printf("   read + Find + seekg     : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
    
    {   std::cout << "7: ";/////////////////////////////////////////////////---7
        t1 = clock();
        std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
        
        size_t size = 100000;
        std::string str; str.assign(size, ' ');
        
        std::string s("ASD123FGH456");
        std::streamoff offset = -s.size();
        
        while (is)
        {   is.read((char*)str.data(), size);
            is.seekg (offset, std::ios::cur);
            
            size_t found = str.find(s);
            if (found != std::string::npos)
            {   std::cout << "Find OK: ";
            
                if     (size - found < MAXSTR) // +
                {   is.seekg (MAXSTR-size, std::ios::cur);
                    is.read((char*)str.data(), size);
                }
                else if(size - found < size - MAXSTR) // -
                {   is.seekg (-MAXSTR-size, std::ios::cur);
                    is.read((char*)str.data(), size);
                }
            
                size_t s1 = str.rfind('\n', found);
                size_t s2 = str.find ('\n', found);
                std::cout << str.substr(s1, s2-s1) << std::endl;
            };
        }
        printf("   read + Find + seekg     : Time = %f(школа)\n\n",
               (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        is.close();
    }
 
    std::cout << "\n\n";
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <fstream>
#include <string>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <Windows.h>
#include <vector>
#include <exception>
#include <stdio.h>
 
int FindRowsInCSVansi(PCTSTR path, const char* findStr, bool multiLine, bool noBuffering)
{
    const DWORD  nNumberOfBytesToRead = 16777216;//67108864;//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; //счетчик строк
size_t findStrLen = strlen(findStr); //счетчик строк
std::string strOut; //итоговая строка
DWORD dwBytesReadWork;
DWORD findStatus = 0; //статус поиска
ULONGLONG ignoreOffset=0; //для расчета холостых циклов
bool errHandleEOF = 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 | (noBuffering ? 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: { errHandleEOF = 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 (errHandleEOF) { 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\n" << strOut << std::endl;
CloseHandle(hFile);
CloseHandle(hEndRead);
delete[] notAlignBuf;
delete[] notAlignBufBufWork;
return 0;
return1:
CloseHandle(hFile);
CloseHandle(hEndRead);
delete[] notAlignBuf;
delete[] notAlignBufBufWork;
return -1;
}
 
int createfile() //создание файла для теста
{
    const int N = 4000000; // количество строк в файле
    std::ofstream fout("C:\\CSV_1_GB.csv");
    std::string str = "Пятый; Тридацть четвертый; 44221100; BBB; CIFRAPOLE; POLEPVTRETYE; ODIN ODIN - TRI; CC; 01.01.2013; 01.01.2013; 8963; 2UTY39ADVGKR; СU707039; 40200М У0026034; -; 11; 2; 150; 1998; 1; -; 21; 1980; 1490; НОМЕР ПЯТЬ; -; ПОЛЕ ОДИН; ПОЛЕ ОДИН ПЯТЬ; -; -";
    if (!fout){ return 1; }
 
    for (int i = 0; i < N; ++i)
    {
        fout << i + 1;
        fout << str << std::endl;
    }
    fout.close();
    return 0;
}
 
#pragma warning(disable : 4146)
int XLAT()
{
    clock_t t1;
    clock_t t2;
 
    size_t MAXSTR = 1024;
    const char* const NAMEFILE = "C:\\CSV_1_GB.csv";
    t1 = clock();
    std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
 
    size_t size = 100000;
    std::string str; str.assign(size, ' ');
 
    std::string s("4000000");
    std::streamoff offset = -s.size();
 
    while (is)
    {
        is.read((char*)str.data(), size);
        is.seekg(offset, std::ios::cur);
 
        size_t found = str.find(s);
        if (found != std::string::npos)
        {
            std::cout << "Find OK: ";
 
            if (size - found < MAXSTR) // +
            {
                is.seekg(MAXSTR - size, std::ios::cur);
                is.read((char*)str.data(), size);
                found -= MAXSTR;
            }
            else if (size - found > size - MAXSTR) // -
            {
                is.seekg(-MAXSTR - size, std::ios::cur);
                is.read((char*)str.data(), size);
                found += MAXSTR;
            }
 
            size_t s1 = str.rfind('\n', found);
            size_t s2 = str.find('\n', found);
            std::cout << str.substr(s1, s2 - s1) << std::endl;
        };
    }
    is.close();
    printf("   read + Find + seekg     : Time = %f(школа)\n\n",
        (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
 
 
}
int main() 
{
    if (createfile() != 0) { return 1; }; //генератор данных в файле
    clock_t t1;
    clock_t t2;
    int x;
 
    t1 = clock();
    if ((x = FindRowsInCSVansi(L"C:\\CSV_1_GB.csv","4000000",0,1)) > -1)
    {
        t2 = clock();
        printf("bedvit1: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    XLAT();
 
    t1 = clock();
    if ((x = FindRowsInCSVansi(L"C:\\CSV_1_GB.csv", "4000000", 0, 1)) > -1)
    {
        t2 = clock();
        printf("bedvit2: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    XLAT();
 
    system("pause");
    return 0;
}

#pragma warning(disable : 4146)
std::string XLAT(std::string s)
{
    clock_t t1;
    clock_t t2;
 
    size_t MAXSTR = 1024;
    const char* const NAMEFILE = "C:\\CSV_1_GB.csv";
    t1 = clock();
    std::ifstream is(NAMEFILE, std::ios::in | std::ios::binary);
 
    size_t size = 100000;
    std::string str; str.assign(size, ' ');
 
    //std::string s(findStr);
    std::streamoff offset = -s.size();
 
    std::string sOut;
 
    while (is)
    {
        is.read((char*)str.data(), size);
        is.seekg(offset, std::ios::cur);
 
        size_t found = str.find(s);
        if (found != std::string::npos)
        {
            //std::cout << "Find OK: ";
 
            if (size - found < MAXSTR) // +
            {
                is.seekg(MAXSTR - size, std::ios::cur);
                is.read((char*)str.data(), size);
                found -= MAXSTR;
            }
            else if (size - found > size - MAXSTR) // -
            {
                is.seekg(-MAXSTR - size, std::ios::cur);
                is.read((char*)str.data(), size);
                found += MAXSTR;
            }
 
            size_t s1 = str.rfind('\n', found);
            size_t s2 = str.find('\n', found);
            //std::cout << str.substr(s1, s2 - s1) << std::endl;
            sOut = sOut + str.substr(s1+1, s2 - s1);
            return sOut;
        };
    }
    is.close();
    //std::cout << sOut << std::endl;
    //printf("   read + Find + seekg     : Time = %f(школа)\n\n",
    //  (clock() - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    return sOut;
}
 
std::string FindRowsInCSVansiNew(PCTSTR path, const char* findStr, bool multiLine, bool noBuffering)
{
    const DWORD  nNumberOfBytesToRead = 16777216;//67108864;//33554432; //16777216;//8388608;//читаем в буфер байты
    if (strlen(findStr) >= nNumberOfBytesToRead) { return ""; }; 
    char* notAlignBuf = new char[nNumberOfBytesToRead + 4096]; //буфер
    char* buf = notAlignBuf; //буфер
    if (size_t(buf) % 4096) { buf += 4096 - (size_t(buf) % 4096); }//адрес принимающего буфера тоже должен быть выровнен по размеру сектора/страницы 
 
    char* notAlignBufWork = new char[nNumberOfBytesToRead*2 + 4096 +  1]; //буфер Рабочий
    char* bufWork = notAlignBufWork + nNumberOfBytesToRead; //буфер
    if (size_t(bufWork) % 4096) { bufWork += 4096 - (size_t(bufWork) % 4096); }//адрес рабочего буфера тоже выровнял по размеру сектора/страницы  
 
    bufWork[0] = '\0';//добавим нуль-терминатор
    bufWork[nNumberOfBytesToRead] = '\0';//добавим нуль-терминатор
    char* find;// указатель для поиска
    size_t strCount = 1; //счетчик строк
    size_t findStrLen = strlen(findStr);
    std::string strOut; //итоговая строка
    DWORD dwBytesReadWork=0;
    DWORD findStatus = 0; //статус поиска
    //ULONGLONG ignoreOffset = 0; //для расчета холостых циклов
    bool errHandleEOF = false; //метка конца файла
 
    char* strStart;
    char* strEnd;
    char* bufWorkNew = bufWork;//буфер с учетом полной строки
    size_t strStartLen=0;
 
    // создаем события с автоматическим сбросом
    HANDLE hEndRead = CreateEvent(NULL, FALSE, FALSE, NULL);// дескриптор события
    //if (hEndRead == NULL) { return GetLastError(); }
    if (hEndRead == NULL) { return ""; }
 
    _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 | (noBuffering ? FILE_FLAG_NO_BUFFERING : FILE_FLAG_RANDOM_ACCESS),// асинхронный ввод//отключаем системный буфер
        NULL                   // шаблона нет
    );
    // проверяем на успешное открытие
    if (hFile == INVALID_HANDLE_VALUE)
    {
        CloseHandle(hEndRead);
        delete[] notAlignBuf;
        delete[] notAlignBufWork;
        return "";
    }
    // читаем данные из файла
    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: { errHandleEOF = true;   break; } // мы достигли конца файла читалкой ReadFile
            default: {goto return1; }// другие ошибки
            }
        }
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
        bufWork[dwBytesReadWork] = '\0';//добавим нуль-терминатор
                //strStart = bufWork;
                //char* strEnd = NULL;
    go_1:
        if (findStatus == 0)//goFind
        {
            find = strstr(bufWorkNew, findStr);
            if (find != NULL) //если нужная подстрока найдена
            {
                for (strStart = find; strStart >= bufWorkNew; strStart--)
                {
                    if (*strStart == '\n') { break; } //если нашли начало строки
                }
                strStart++; //не учитываем '\n'
 
                strEnd = strchr(find, '\n'); //ищем конец строки
                if (strEnd != NULL) //если нашли конец строки
                {
                    strOut = strOut + std::string(strStart, strEnd - strStart + 1);
                    if (!multiLine)
                    {
                        goto return0;
                    }
                    else//поиск в следующей строке начинаем с конца предыдущей
                    {
                        bufWorkNew = strEnd++;
                        findStatus = 0;
                        goto go_1;
                    }
                }
                else//если конец строки в следующем буфере или конец файла
                {
                    strOut = strOut + std::string(strStart);
                    findStatus = 1;
                }
                
            } //если нужная подстрока найдена
        }
        else if (findStatus == 1)//goBuf
        {
            strEnd = strchr(bufWork, '\n');
            if (strEnd != NULL) //если нашли конец строки
            {
                strOut = strOut + std::string(bufWork, strEnd - bufWork + 1);
                findStatus = 0;
                if (!multiLine)
                {
                    goto return0;
                }
                else//поиск в следующей строке начинаем с конца предыдущей
                {
                    bufWorkNew = strEnd++;
                    findStatus = 0;
                    goto go_1;
                }
            }
            else//если конец строки в следующем буфере или конец файла
            {
                strOut = strOut + std::string(bufWork);
            }
        }
 
        //блок дозагрузки основного буфера межбуферной строкой
        char* bufWorkEnd = bufWork + dwBytesReadWork; //конец буфера
        for (strStart = bufWorkEnd; strStart >= bufWork; strStart--) { if (*strStart == '\n') { break; } } //если нашли начало строки
        if (strStart < bufWork && ui.QuadPart>=nNumberOfBytesToRead) { goto return1; }; //если строка больше буфера (не найден разделитель), кроме первого буфера
        strStartLen = (bufWorkEnd - ++strStart); //размер буфера, который добавляем к рабочему
        bufWorkNew = bufWork - strStartLen;
        memcpy(bufWorkNew, strStart, strStartLen);
        //////////////////////
        if (errHandleEOF) { goto return0; }
        //работаем асинхронно, выполняем код, пока ждем чтение с диска//
 
        // ждем, пока завершится асинхронная операция чтения
        WaitForSingleObject(hEndRead, INFINITE);
 
        // проверим результат работы асинхронного чтения // если возникла проблема ... 
        if (!GetOverlappedResult(hFile, &ovl, &dwBytesRead, FALSE))
        {
            switch (dwError = GetLastError())// решаем что делать с кодом ошибки
            {
            case ERROR_HANDLE_EOF:{ 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;// вносим смещение в старшеее слово
        //ovl.Offset += nNumberOfBytesToRead;
    }
 
return0:
    // закрываем дескрипторы, освобождаем память
    //std::cout << "String Find\n" << strOut << std::endl;
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
    return strOut;
return1:
    CloseHandle(hFile);
    CloseHandle(hEndRead);
    delete[] notAlignBuf;
    delete[] notAlignBufWork;
    return "";
}
 
 
int main() 
{
    std::string sOut;
    std::string sOut2;
    clock_t t1;
    clock_t t2;
    int x;
 
    for (int i = 1; i <= 4000000; i++)
    {
        sOut = FindRowsInCSVansiNew(L"C:\\CSV_1_GB.csv", std::to_string(i).c_str(), 0, 0);
        sOut2 = XLAT(std::to_string(i));
        if (sOut != sOut2)
        {
            std::cout <<"find: "<<i<<"\nbedvit\n"<< sOut << std::endl;
            std::cout <<"XLAT\n"<<sOut2 << std::endl;
        }
    }
 
    system("pause");
    return 0;
}

int main() 
{
 
    std::string sOut;
    std::string sOut2;
 
    //if (createfile() != 0) { return 1; }; //генератор данных в файле
    clock_t t1;
    clock_t t2;
 
    std::cout << "\n\FILE_FLAG_NO_BUFFERING\n" << std::endl;
    for (int i = 1; i <= 5; i++)
    {
        t1 = clock();
        sOut = FindRowsInCSVansiNew(L"C:\\CSV_1_GB.csv", "4000000", 0, 1);
        t2 = clock();
        printf("bedvit1: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
        t1 = clock();
        sOut2 = XLAT("4000000");
        t2 = clock();
        printf("XLAT: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    //кешировано
    std::cout << "\n\FILE_FLAG_BUFFERING\n" << std::endl;
    for (int i = 1; i <= 5; i++)
    {
        t1 = clock();
        sOut = FindRowsInCSVansiNew(L"C:\\CSV_1_GB.csv", "4000000", 0, 0);
        t2 = clock();
        printf("bedvit1: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
        t1 = clock();
        sOut2 = XLAT("4000000");
        t2 = clock();
        printf("XLAT: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    }
 
    system("pause");
    return 0;
}