#include <windows.h>
#include <stdint.h>
#include <stdio.h>
#include <assert.h>

#define READER_COUNT 3
#define MESSAGE_COUNT 1000000

//*******************************************************************
//* SHARED DATA *****************************************************
//*******************************************************************

struct data_t {
	volatile int number;
	volatile long need_read;
};
#pragma data_seg("Shared")
data_t shared_data = { 0 };
#pragma data_seg()
#pragma comment(linker, "/SECTION:Shared,RWS")

//*******************************************************************
//* WRITER **********************************************************
//*******************************************************************

void writer() {
	HANDLE reader_event = OpenEvent(EVENT_ALL_ACCESS, false, "SharedMemoryReader");
	HANDLE writer_event = OpenEvent(EVENT_ALL_ACCESS, false, "SharedMemoryWriter");
	assert(reader_event != NULL && writer_event != NULL);
	long init_mask = (1 << READER_COUNT) - 1;
	printf("test: % d msg  %d readers\n", MESSAGE_COUNT, READER_COUNT);
	uint32_t t = GetTickCount();
	// Отправка сообщений
	while(shared_data.number != 0) {
		shared_data.number--; // Заполнение сообщения

		shared_data.need_read = init_mask; // Маска списка читателей

		SetEvent(reader_event); // Пробуждение читателей
		WaitForSingleObject(writer_event, INFINITE); // Ожидание завершения чтения
	}
	CloseHandle(writer_event);
	CloseHandle(reader_event);
	uint32_t time = GetTickCount() - t;
	printf("time %d msec  speed %d msg/sec\n", time, MESSAGE_COUNT * 1000 / (time == 0 ? 1 : time));
}

//*******************************************************************
//* READER **********************************************************
//*******************************************************************
void start_readers() {
	shared_data.number = MESSAGE_COUNT;
	HANDLE reader_event = CreateEvent(NULL, true, false, "SharedMemoryReader");
	HANDLE writer_event = CreateEvent(NULL, false, false, "SharedMemoryWriter");
	assert(reader_event != NULL && writer_event != NULL);
	// Запуск читателей
	for (size_t i = 0; i != READER_COUNT; i++) {
		STARTUPINFO si = { sizeof(si) };
		PROCESS_INFORMATION pi;
		char buf[1024];
		sprintf_s(buf, sizeof(buf), "TestMapped.exe %d", i);
		printf("run: %s\n", buf);
		CreateProcess(NULL, buf, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi);
		CloseHandle(pi.hThread);
		CloseHandle(pi.hProcess);
	}
	Sleep(500);
	CloseHandle(writer_event);
	CloseHandle(reader_event);
}

// Прием сообщений
void reader(char *name) {
	long num = atoi(name);
	printf("reader#%d start ...\n", num);
	HANDLE reader_event = OpenEvent(EVENT_ALL_ACCESS, false, "SharedMemoryReader");
	HANDLE writer_event = OpenEvent(EVENT_ALL_ACCESS, false, "SharedMemoryWriter");
	assert(reader_event != NULL && writer_event != NULL);
	int64_t sum = 0;
	long mask = 1 << num, not_mask = ~mask;
	while(shared_data.number != 0) { // Последнее сообщение 0
		WaitForSingleObject(reader_event, INFINITE); // Ожидание заполнения сообщения

		if((shared_data.need_read & mask) == 0) {
			// Это сообщение уже обработано
			if(shared_data.need_read != 0) SwitchToThread();
			continue;
		}

		// Обработка сообщения
		sum += shared_data.number;

		// Снятие флага обработки
		long old;
		do {
			old = shared_data.need_read;
		} while (InterlockedCompareExchange(&shared_data.need_read, old & not_mask, old) != old);
		if (old == mask) {
			// Закончил последний читатель
			ResetEvent(reader_event);
			SetEvent(writer_event);
		}
	}
	SetEvent(writer_event);
	CloseHandle(writer_event);
	CloseHandle(reader_event);
	printf("sum = %lld\n", sum);
}

//*******************************************************************
int main(int argc, char **argv) {
	if(argc > 1) {
		reader(argv[1]);
	} else {
		start_readers();
		writer();
	}
	system("pause");
}