Memory Mapped IO Test

Author: sahmad98

.gitignore

@@ -1,2 +1,5 @@
 build/
 .vscode/
+*.rpt
+*.o
+*.s

CMakeLists.txt

@@ -1,30 +1,38 @@
 cmake_minimum_required(VERSION 3.10)
 
-project(PerfTest)
+project(PerfTest LANGUAGES CXX C)
 
-set(LOCAL "/usr/local/include")
-set(CMAKE_CXX_STANDARD 11)
-add_definitions("-msse4 -g")
 set(SOURCE ${PROJECT_SOURCE_DIR}/src)
 #set(EXECUTABLE_OUTPUT_PATH bin)
 include_directories(${LOCAL})
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -pthread -std=c++17 -fopenmp")
 
 add_executable(RowColumnAccess ${SOURCE}/array_access_test.cpp)
-target_link_libraries(RowColumnAccess PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(CPUPinning ${SOURCE}/cpu_pinning.cpp)
-add_executable(FileReadPerf ${SOURCE}/memory_mapped_io.cpp)
 add_executable(GoogleBench ${SOURCE}/google_benchmark.cpp)
-target_link_libraries(GoogleBench PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(CachePerf ${SOURCE}/cache_perf.cpp)
-target_link_libraries(CachePerf PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(AtomicPerf ${SOURCE}/atomic_perf.cpp)
-target_link_libraries(AtomicPerf PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(VectorizedTest ${SOURCE}/vectorized_test.cpp)
-target_link_libraries(VectorizedTest PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(MiscPerf ${SOURCE}/misc_perf.cpp)
-target_link_libraries(MiscPerf PRIVATE "${LOCAL}/../lib/libbenchmark.a")
 add_executable(LockPerf ${SOURCE}/lock_benchmark.cpp)
-target_link_libraries(LockPerf PRIVATE "${LOCAL}/../lib/libbenchmark.a")
-
+add_executable(FixTest ${SOURCE}/bench_fixture.cpp)
 add_executable(RuntimePolymorphism ${SOURCE}/virtual_functions.cpp)
-target_link_libraries(RuntimePolymorphism PRIVATE "${LOCAL}/../lib/libbenchmark.a")
+add_executable(CacheThrash ${SOURCE}/cache_thrashing.cpp)
+add_executable(MemoryMappedFile ${SOURCE}/memory_mapped_io.cpp)
+add_executable(VecMemCpy ${SOURCE}/vecmemcpy.cpp)
+add_executable(VecStdMemCpy ${SOURCE}/vecstdmemcpy.cpp)
+
+target_link_libraries(RowColumnAccess benchmark)
+target_link_libraries(GoogleBench benchmark)
+target_link_libraries(CachePerf benchmark)
+target_link_libraries(AtomicPerf benchmark)
+target_link_libraries(VectorizedTest benchmark)
+target_link_libraries(MiscPerf benchmark)
+target_link_libraries(LockPerf benchmark)
+target_link_libraries(FixTest benchmark)
+target_link_libraries(RuntimePolymorphism benchmark)
+target_link_libraries(CacheThrash benchmark)
+target_link_libraries(MemoryMappedFile benchmark)
+target_link_libraries(VecMemCpy benchmark)
+target_link_libraries(VecStdMemCpy benchmark)

src/array_access_test.cpp

@@ -1,6 +1,7 @@
 #include <iostream>
 #include <chrono>
 #include <benchmark/benchmark.h>
+#include <vector>
 
 using namespace std;
 
@@ -15,6 +16,7 @@ int** allocateArray(uint64_t size) {
 //Cache hit
 void row_wise_access(int** array, int size) {
     int result = 0;
+    // loop
     for(int i=0; i<size; i++)
         for(int j=0; j<size; j++) {
             result += array[i][j];
@@ -31,6 +33,7 @@ void deallocateArray(int** arr, int size) {
 //Cache miss
 void column_wise_access(int** array, int size) {
     int result = 0;
+    // loop
     for(int i=0; i<size; i++)
         for(int j=0; j<size; j++) {
             result += array[j][i];
@@ -41,7 +44,8 @@ static void BM_row_wise_access(benchmark::State& state) {
     int size = state.range(0);
     int** arr = allocateArray(size);
     for (auto _ : state) {
-        row_wise_access(arr, size);
+	    row_wise_access(arr, size);
+	    benchmark::ClobberMemory();
     }
     deallocateArray(arr, size);
 }

src/lock_benchmark.cpp

@@ -1,7 +1,7 @@
 #include <benchmark/benchmark.h>
 #include <atomic>
 
-static uint64_t lock_underlying = 0;
+uint32_t lock_underlying = 0;
 
 class SpinLock {
     std::atomic_flag locked = ATOMIC_FLAG_INIT ;
@@ -16,27 +16,27 @@ class SpinLock {
 
 static SpinLock spinlock;
 
-void lock(uint64_t* underlying) {
+void lock(uint32_t* underlying) {
     do {} while(not __sync_bool_compare_and_swap(underlying, 0, 1));
 }
 
-void unlock(uint64_t* underlying) {
+void unlock(uint32_t* underlying) {
     do {} while(not __sync_bool_compare_and_swap(underlying, 1, 0));
 }
 
 void readModifyWrite(int* num) {
     lock(&lock_underlying);
-    for (int i=0; i<1000; i++) {
+    /*for (int i=0; i<1000; i++) {
         *num = *num + 1;
-    }
+    }*/
     unlock(&lock_underlying);
 }
 
 void readModifyWriteGccLock(int *num) {
     spinlock.lock();
-    for (int i=0; i<1000; i++) {
+    /*for (int i=0; i<1000; i++) {
         *num = *num + 1;
-    }
+    }*/
     spinlock.unlock();
 }
 

src/memory_mapped_io.cpp

@@ -1,7 +1,103 @@
 #include <iostream>
-#include <fstream>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <cstring>
+#include <benchmark/benchmark.h>
 
-int main() {
-	return 0;
+static constexpr auto kMaxSize = 8192;
+char data[kMaxSize];
+
+static void BM_MemMappedRead(benchmark::State& state) {
+	int fd = open("../resources/data.bin", O_RDONLY | O_CLOEXEC);
+	if (fd < 0) {
+		std::cout << "Error in Opening file" << errno << "\n";
+	}
+
+	char* map = (char*)mmap(NULL, kMaxSize, PROT_READ, MAP_SHARED, fd, 0);
+	if (!map) {
+		std::cout << "Error in mapping " << errno << std::endl;
+	}
+
+	size_t size = state.range(0);
+	for (auto _ : state) {
+		std::memcpy(data, map, size);
+	}
+
+	close(fd);
+	munmap(map, kMaxSize);
+}
+
+static void BM_MemMappedWrite(benchmark::State& state) {
+	int fd = open("../resources/data_write_map.bin", O_RDWR | O_CLOEXEC);
+	if (fd < 0) {
+		std::cout << "Error in Opening file " << errno << "\n";
+	}
+
+	char* map = (char*)mmap(NULL, kMaxSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+	if (!map) {
+		std::cout << "Error in mapping " << errno << std::endl;
+	}
+
+	size_t size = state.range(0);
+	for (auto _ : state) {
+		std::memcpy(map, data, size);
+	}
+
+	close(fd);
+	munmap(map, kMaxSize);
+}
+
+
+#define min_(x, y) x < y ? x : y
+
+static void BM_ReadSyscall(benchmark::State& state) {
+	int fd = open("../resources/data.bin", O_RDONLY | O_CLOEXEC);
+	if (fd < 0) {
+		std::cout << "Error in Opening file" << errno << "\n";
+	}
+
+	size_t size = state.range(0);
+	for (auto _ : state) {
+		int total_read = 0;
+		if (lseek(fd, 0, SEEK_SET) < 0) {
+			std::cerr << "Error in Seeking " << errno << std::endl;
+			return;
+		}
+		while(total_read < size) {
+			size_t read_size = min_(size, size - total_read);
+			total_read += read(fd, data + total_read, read_size);
+		}
+	}
+
+	close(fd);
 }
 
+static void BM_WriteSyscall(benchmark::State& state) {
+	int fd = open("../resources/data_write_sys.bin", O_RDONLY | O_CLOEXEC);
+	if (fd < 0) {
+		std::cout << "Error in Opening file" << errno << "\n";
+	}
+
+	size_t size = state.range(0);
+	for (auto _ : state) {
+		int total_write = 0;
+		if (lseek(fd, 0, SEEK_SET) < 0) {
+			std::cerr << "Error in Seeking " << errno << std::endl;
+			return;
+		}
+		while(total_write < size) {
+			size_t write_size = min_(size, size - total_write);
+			total_write += read(fd, data + total_write, write_size);
+		}
+	}
+
+	close(fd);
+}
+
+BENCHMARK(BM_MemMappedRead)->Range(64, 8 << 10);
+BENCHMARK(BM_ReadSyscall)->Range(64, 8 << 10);
+BENCHMARK(BM_MemMappedWrite)->Range(64, 8 << 10);
+BENCHMARK(BM_WriteSyscall)->Range(64, 8 << 10);
+BENCHMARK_MAIN();
+