Void main()

{

int s;

DWORD start, finish;

setlocale(LC_ALL, "Russian");

do {

inFileHandle = CreateF(true);

outFileHandle = CreateF(false);

if (inFileHandle != INVALID_HANDLE_VALUE && inFileHandle != INVALID_HANDLE_VALUE)

{

LARGE_INTEGER curPos;

cout << "\nВыберите размер копируемых блоков: ";

cout << "\n1) 512";

cout << "\n2) 1024";

cout << "\n3) 2048";

cout << "\n4) 4096";

cout << "\n5) 8192";

cout << "\n6) 16384";

cout << "\n7) 32768";

cout << "\n8) 65536";

cout << "\n9) 131072";

cout << "\n10) 262144\n";

cin >> s;

switch (s)

{

case 1:

BLOCK_SIZE = 512;

break;

case 2:

BLOCK_SIZE = 1024;

break;

case 3:

BLOCK_SIZE = 2048;

break;

case 4:

BLOCK_SIZE = 4096;

break;

case 5:

BLOCK_SIZE = 8192;

break;

case 6:

BLOCK_SIZE = 16384;

break;

case 7:

BLOCK_SIZE = 32768;

break;

case 8:

BLOCK_SIZE = 65536;

break;

case 9:

BLOCK_SIZE = 131072;

break;

case 10:

BLOCK_SIZE = 262144;

break;

default:

BLOCK_SIZE = 512;

break;

}

cout << "Выберите число перекрывающихся операций: ";

cout << "\n1) 1";

cout << "\n2) 2";

cout << "\n3) 4";

cout << "\n4) 8";

cout << "\n5) 12";

cout << "\n6) 16\n";

cin >> s;

switch (s)

{

case 1:

MAX_OVR = 1;

break;

case 2:

MAX_OVR = 2;

break;

case 3:

MAX_OVR = 4;

break;

case 4:

MAX_OVR = 8;

break;

case 5:

MAX_OVR = 12;

break;

case 6:

MAX_OVR = 16;

break;

default:

MAX_OVR = 1;

break;

}

buf = new CHAR *[MAX_OVR];

for (int k = 0; k < MAX_OVR; k++)

buf[k] = new CHAR[BLOCK_SIZE];

ovrIn = new OVERLAPPED[MAX_OVR];

ovrOut = new OVERLAPPED[MAX_OVR];

BY_HANDLE_FILE_INFORMATION fileInformation;

if (!GetFileInformationByHandle(inFileHandle, &fileInformation))

{

cout << "Error!";

return;

}

fileSize.LowPart = (fileInformation.nFileSizeHigh * (MAXDWORD + 1)) + fileInformation.nFileSizeLow;

cout << "\nРазмер файла: " << fileSize.QuadPart / 1024 << endl;

nRecords = fileSize.QuadPart / BLOCK_SIZE + (fileSize.QuadPart%BLOCK_SIZE > 0 ? 1 : 0);

cout << "Число записей: " << nRecords << endl;

curPos.QuadPart = 0;

DWORD i;

BOOL success = 0;

start = timeGetTime();

for (i = 0; i < MAX_OVR; i++)

{

ovrIn[i].hEvent = (HANDLE)i;

ovrOut[i].hEvent = (HANDLE)i;

ovrIn[i].Offset = curPos.LowPart;

ovrIn[i].OffsetHigh = curPos.HighPart;

if (curPos.QuadPart < fileSize.QuadPart)

{

ReadFileEx(inFileHandle, buf[i], BLOCK_SIZE, &ovrIn[i], ReadCallback);

}

curPos.QuadPart = curPos.QuadPart + (LONGLONG)BLOCK_SIZE;

}

nDoneRead = 0;

while (nDoneRead < nRecords)

SleepEx(INFINITE, TRUE);

LONGLONG nBytes = nRecords * BLOCK_SIZE;

SetFilePointer(outFileHandle, -(nBytes - fileSize.QuadPart), NULL, FILE_END);

SetEndOfFile(outFileHandle);

finish = timeGetTime();

cout << "\nВремя копирования в миллисекундах: " << finish - start << endl;

CloseHandle(inFileHandle);

CloseHandle(outFileHandle);

delete[] ovrIn;

delete[] ovrOut;

for (int i = 0; i < MAX_OVR; i++)

delete[] buf[i];

delete[] buf;

}

else

cout << "\nError opening file.\n";

cout << "\nДля повтора введите - 1, для выхода - 0\n";

cin >> s;

} while (s);

_getch();

}

HANDLE CreateF(bool flag)

{

char name[MAX_PATH + 1];

flag ? cout << "Введите имя исходного файла: " : cout << "Введите имя файла результата: ";

cin >> name;

HANDLE FileHandle = CreateFileA(name, flag ? GENERIC_READ : GENERIC_WRITE, 0,

NULL, flag ? OPEN_EXISTING : CREATE_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);

return FileHandle;

}

VOID CALLBACK ReadCallback(DWORD error, DWORD countOfBytes, LPOVERLAPPED pOvr)

{

LARGE_INTEGER curPosIn, curPosOut;

nDoneRead++;

DWORD k = (DWORD)(pOvr->hEvent);

curPosIn.LowPart = ovrIn[k].Offset;

curPosIn.HighPart = ovrIn[k].OffsetHigh;

ovrOut[k].Offset = ovrIn[k].Offset;

ovrOut[k].OffsetHigh = ovrIn[k].OffsetHigh;

WriteFileEx(outFileHandle, buf[k], BLOCK_SIZE, &ovrOut[k], WriteCallback);

curPosIn.QuadPart += BLOCK_SIZE * (LONGLONG)(MAX_OVR);

ovrIn[k].Offset = curPosIn.LowPart;

ovrIn[k].OffsetHigh = curPosIn.HighPart;

return;

}

VOID CALLBACK WriteCallback(DWORD error, DWORD countOfBytes, LPOVERLAPPED pOvr)

{

LARGE_INTEGER curPos;

nDoneWrite++;

DWORD k = (DWORD)(pOvr->hEvent);

curPos.LowPart = ovrIn[k].Offset;

curPos.HighPart = ovrIn[k].OffsetHigh;

if (curPos.QuadPart < fileSize.QuadPart)

ReadFileEx(inFileHandle, buf[k], BLOCK_SIZE, &ovrIn[k], ReadCallback);

return;

}

Санкт-Петербург

2016