win 环境不同API磁盘速度上限测试

#include <iostream>
#include <fstream>
#include <chrono>
#include <vector>
#include <Windows.h>


VOID CALLBACK FileIOCompletionRoutine(
	__in  DWORD dwErrorCode,
	__in  DWORD dwNumberOfBytesTransfered,
	__in  LPOVERLAPPED lpOverlapped)
{
}

int diskTest()
{
	const int BLOCKS = 1024;
	const int BLOCK_SIZE = 1024 * 1024;
	auto filename = "F:/test.dat";

	auto start = std::chrono::high_resolution_clock::now();

	std::vector<char> buf(BLOCK_SIZE);
	auto file = std::ofstream(filename, std::ios::binary);
	for (int i = 0; i < BLOCKS; ++i) {
		file.write(buf.data(), buf.size());
	}
	auto stop = std::chrono::high_resolution_clock::now();

	auto costTime = (stop - start).count() / 1e9;
	std::cout << "write 1G cost time: " << costTime << std::endl;
	std::cout << "speed: " << 1 / costTime << std::endl;
	return 0;
}

int diskTest1()
{
	const int BLOCKS = 1024;
	const int BLOCK_SIZE = 1024 * 1024;
	auto filename = "F:/test.dat";

	auto start = std::chrono::high_resolution_clock::now();

	std::vector<char> buf(BLOCK_SIZE);

	HANDLE hfile = CreateFileA(filename,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_WRITE | FILE_SHARE_READ,
		NULL,
		OPEN_ALWAYS,
		FILE_ATTRIBUTE_NORMAL | FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		NULL);
	if (hfile == INVALID_HANDLE_VALUE) {
		std::cout << "Can't open" << filename << std::endl;
		return false;
	}

	for (int i = 0; i < BLOCKS; ++i) {
		DWORD dwWritten;     //保存写了多少字节到文件中
		WriteFile(hfile, buf.data(), buf.size(), &dwWritten, 0);
	}
	CloseHandle(hfile);

	auto stop = std::chrono::high_resolution_clock::now();
	auto costTime = (stop - start).count() / 1e9;
	std::cout << "write 1G cost time: " << costTime << std::endl;
	std::cout << "speed: " << 1 / costTime << std::endl;
	return 0;
}

int diskTest2()
{
	const int BLOCKS = 1024;
	const int BLOCK_SIZE = 1024 * 1024;
	auto filename = "F:/test.dat";

	auto start = std::chrono::high_resolution_clock::now();

	std::vector<char> buf(BLOCK_SIZE);

	HANDLE hFile = CreateFileA(filename,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_ALWAYS,
		FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		NULL);

	if (hFile == INVALID_HANDLE_VALUE) {
		return -1;
	}

	std::vector<OVERLAPPED> ols(BLOCKS);
	std::vector<HANDLE> events(BLOCKS);

	for (int i = 0; i < BLOCKS; ++i) {
		events[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
		ols[i].Offset = i * buf.size();
		ols[i].hEvent = events[i];
		DWORD written = 0;
		BOOL rc = WriteFile(hFile, buf.data(), buf.size(), &written, &ols[i]);
		if (rc) {
			// done
		}
		else if (GetLastError() == ERROR_IO_PENDING) {
			// wait
			//WaitForSingleObject(&events[i], INFINITE);
			//bool rc = GetOverlappedResult(&events[i], &ols[i], &written, FALSE);
		}
		else {
			// failed
			return -1;
		}
	}

	//WaitForMultipleObjects(BLOCKS, events.data(), TRUE, INFINITE);
	for (int i = 0; i < BLOCKS; ++i) {
		WaitForSingleObject(&events[i], INFINITE);
		DWORD written = 0;
		bool rc = GetOverlappedResult(hFile, &ols[i], &written, FALSE);
	}

	CloseHandle(hFile);

	auto stop = std::chrono::high_resolution_clock::now();
	auto costTime = (stop - start).count() / 1e9;
	std::cout << "write 1G cost time: " << costTime << std::endl;
	std::cout << "speed: " << 1 / costTime << std::endl;
	return 0;
}


int diskTest3()
{
	const int BLOCKS = 1024;
	const int BLOCK_SIZE = 1024 * 1024;
	auto filename = "F:/test.dat";

	auto start = std::chrono::high_resolution_clock::now();

	std::vector<char> buf(BLOCK_SIZE);

	HANDLE hfile = CreateFileA(filename, 
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_WRITE | FILE_SHARE_READ, 
		NULL,
		OPEN_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		NULL);
	if (hfile == INVALID_HANDLE_VALUE) {
		std::cout << "Can't open" << filename << std::endl;
		return false;
	}

	std::vector<OVERLAPPED> ols(BLOCKS);
	std::vector<HANDLE> events(BLOCKS);

	for (int i = 0; i < BLOCKS; ++i) {
		events[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
		ols[i].hEvent = events[i];
		ols[i].Offset = i * buf.size();
		if (FALSE == WriteFileEx(hfile, buf.data(), buf.size(), &ols[i], FileIOCompletionRoutine))
		{
			CloseHandle(hfile);
			return -1;
		}

		SleepEx(INFINITE, TRUE);
	}

	CloseHandle(hfile);

	auto stop = std::chrono::high_resolution_clock::now();
	auto costTime = (stop - start).count() / 1e9;
	std::cout << "write 1G cost time: " << costTime << std::endl;
	std::cout << "speed: " << 1 / costTime << std::endl;
    return 0;
}