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

Самое быстрое - это читать и записывать блоками (какого размера точно не понятно, но около 50000 и больше);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
#include <iostream>
#include <string>
#include <ctime>
#include <fstream>
 
using namespace std;
 
const int N = 1000000; // количество строк в файле
const int L = 500;     // длина строки
 
void createfile() //создание файла для теста
{
    string str = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
    ofstream fout("file1.txt");
    for (int i = 0; i < N; ++i)
    {
        fout << i + 1;
        fout << str << endl;
    }
    fout.close();
}
 
int main()
{
    //createfile(); //создание файла для теста
 
    const int size = 51200;
    char* buffer = new char[size];
    //char buffer[size];
    char str1[L] = {'\0'};
    
    clock_t t1 = clock();
    FILE *fin = fopen("file1.txt", "rb"); // в бинарном быстрее
    
    if (!fin) printf("Error!\n");
    else
    {
        FILE *fout = fopen("file2.txt", "wb");
 
        // посимвольно
        /*begin...............................
         char ch;
         while (true)
         {
             ch = fgetc(fin);
             if (feof(fin))
                 break;
         }
            
        //*///end ...................................
        
        // построчно
      /*begin...............................
        
          while (fgets(str1, L, fin))
                fputs(str1, fout);
      //*///end ................................... 
 
      // блоками
     /*begin...............................
         //int n = 0;
         while (fread(buffer, size, 1, fin))
            fwrite(buffer, size, 1, fout);
             //++n;
        
     //*///end ...................................  
    
     // блоком, размером с размер файла
     /*begin...............................
        
        fseek(fin, 0, SEEK_END); 
        int size = ftell(fin);
        char * buffer = (char*) malloc(size);
        
        rewind(fin);
        fread(buffer, 1, size, fin);
        fwrite(buffer, 1, size, fout);
        free(buffer);
     
     //*///end ...................................  
        
        fclose(fout);
        fclose(fin);
        
        clock_t t2 = clock();
        printf("%f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
        printf("\n");
        //printf("%i", n);
    }
  
    system("pause");
    return 0;
}

#include "stdafx.h"
#include <string>
#include <fstream>
#include <ctime>
#include <iostream>
#include <exception>
#include <stdio.h>
 
int main() 
{
    clock_t t1 = clock();
    std::ifstream is;
    std::filebuf * fb = is.rdbuf();
    fb->open("C:\\CSV_1_GB.csv", std::ios::in | std::ios::binary);
        while (is) 
        {
            std::string str;
            std::getline(is, str);
            size_t found = str.find("ASD123FGH456");
            if (found != std::string::npos) { std::cout << "Find OK: " << std::endl; };
        }
    fb->close();
    clock_t t2 = clock();
    printf("SSD KINGSTON SV300S37A120G (120 GB, SATA-III): std::getline + Find: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
    ///////////////////////////////////////////////
    t1 = clock();
    std::ifstream is2;
    std::filebuf * fb2 = is2.rdbuf();
    fb2->open("C:\\CSV_1_GB.csv", std::ios::in | std::ios::binary);
    while (is2) 
    {
        std::string str;
        std::getline(is2, str);
    }
    fb2->close();
    t2 = clock();
    printf("SSD KINGSTON SV300S37A120G (120 GB, SATA-III): std::getline: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
    ///////////////////////////////////////////////
    t1 = clock();
    std::ifstream is3;
    std::filebuf * fb3 = is3.rdbuf();
    fb3->open("D:\\CSV_1_GB.csv", std::ios::in | std::ios::binary);
    while (is3) 
    {
        std::string str;
        std::getline(is3, str);
    }
    fb3->close();
    t2 = clock();
    printf("HDD WDC WD10EACS-00ZJB0 (1000 GB, SATA-II): std::getline: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
    ///////////////////////////////////////////////
#pragma warning(disable : 4996)
    t1 = clock();
    char str[33000];
    char* estr;
    FILE* file;
    file = fopen("C:\\CSV_1_GB.csv", "r");
    if (file != NULL)
    {
        while (1)
        {
            estr = fgets(str, sizeof(str), file);
            if (estr == NULL) { break; }
        }
        fclose(file);
    }
    t2 = clock();
    printf("SSD KINGSTON SV300S37A120G (120 GB, SATA-III): fgets: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
 
    ///////////////////////////////////////////////
    t1 = clock();
    char str2[33000];
    char* estr2;
    FILE* file2;
    file2 = fopen("D:\\CSV_1_GB.csv", "r");
    if (file2 != NULL)
    {
        while (1)
        {
            estr2 = fgets(str, sizeof(str2), file2);
            if (estr2 == NULL) { break; }
        }
        fclose(file2);
    }
    t2 = clock();
    printf("HDD WDC WD10EACS-00ZJB0 (1000 GB, SATA-II): fgets: Time - %f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    system("pause");
    return 0;
}