some cleunup

Makefile

@@ -1,15 +1,49 @@
+CPPC = g++
 FC := gfortran
-FFLAGS := -O3 -g -fbounds-check -Wall -Wextra -cpp -Wno-unused-dummy-argument
+FFLAGS_BASIC = -g -fbacktrace -std=f2008 -pedantic -Wall -Wextra -cpp
+FFLAGS_BASIC += -Werror -Werror=shadow -Werror=intrinsic-shadow -Wuninitialized
+FFLAGS_BASIC += -Wunreachable-code -Wconversion
+FFLAGS_BASIC += -Waliasing -Wampersand -Wc-binding-type -Wcharacter-truncation
+FFLAGS_BASIC += -Wfunction-elimination -Wimplicit-interface -Wimplicit-procedure -Wintrinsic-shadow -Wintrinsics-std -Wline-truncation -Wno-tabs
+FFLAGS_BASIC += -Wreal-q-constant -Wsurprising
+FFLAGS_BASIC += -Wunused-parameter
+FFLAGS_BASIC += -Wno-maybe-uninitialized -Wno-unused-dummy-argument -Wno-error=return-type
+FFLAGS_BASIC += -Wno-unused-function
+FFLAGS_BASIC += -Wno-conversion
+FFLAGS_BASIC += -Wno-implicit-interface -Wno-strict-overflow # implicit interface is necessary for calling qsort with general types. Conversions from/to C ints are harmless.
 
-.PHONY: all test clean ref
+FFLAGS_DEVEL = -O0 -fcheck=all -fbounds-check -Warray-bounds -Wstrict-overflow=5 -Wunderflow -ffpe-trap=invalid,zero,overflow
+# FFLAGS_DEVEL += -ftrapv
+FFLAGS_RELEASE = -O3
+
+# not yet in gfortran 4.8.5:
+# FFLAGS_BASIC += -Wdo-subscript  -std=f2018  -Wfrontend-loop-interchange
+# FFLAGS_DEVEL += -fsanitize-address-use-after-scope
+
+# CPPC = icpc
+# FC = ifort
+# FFLAGS_BASIC = -g -traceback -cpp
+# FFLAGS_DEVEL = -O0
+# FFLAGS_RELEASE = -Ofast
+
+FFLAGS = $(FFLAGS_DEVEL) $(FFLAGS_BASIC)
+
+.PHONY: all test clean
 
 all: test
 
 test: fhash_modules fhash_test.f90
-	$(FC) $(FFLAGS) fhash_modules.f90 fhash_test.f90 -o fhash_test.out && ./fhash_test.out
+	$(FC) $(FFLAGS) fhash_modules.f90 fhash_test.f90 -o fhash_test.out  \
+        &&   ./fhash_test.out
+
+benchmark: fhash_benchmark.out stl_benchmark.out
+	./fhash_benchmark.out  &&  ./stl_benchmark.out
+
+fhash_benchmark.out: fhash.f90 fhash_modules.f90 benchmark.f90
+	$(FC) $(FFLAGS_BASIC) $(FFLAGS_RELEASE) fhash_modules.f90 benchmark.f90 -o fhash_benchmark.out
 
-ref: benchmark.cc
-	g++ -O3 -std=c++14 benchmark.cc -o ref.out && ./ref.out
+stl_benchmark.out: benchmark.cc
+	 $(CPPC) -std=c++11 -O3 $< -o $@
 
 clean:
 	rm -rf *.mod *.o

README.md

@@ -2,44 +2,41 @@
 Fast hash map implementation in fortran
 
 ## Description
-Implemention of the GCC hashmap structure in Fortran. With the usage of macros, it can support any types of keys and values, as long as you implement (or the compiler provides) the corresponding equal operator(==), assignment operator(=) and the hash_value interface of the key type and the assignment operator of the value type.
+Implemention of the GCC hashmap structure in Fortran. It supports any types of keys and values, as long as you set the following macros:
 
-## Benchmarks
+* `FHASH_NAME`;
+
+* `KEY_TYPE` and `VALUE_TYPE` with corresponding use statements `KEY_USE` and `VALUE_USE`,
+
+and, optionally,
 
-Here are the benchmarks between my Fortran implementation and GCC 4.8 standard library:
+* `KEYS_EQUAL_FUNC`: the comparison operator for the keys (defaults to either `a == b` or `all(a == b)`, depending on whether the key is a scalar;
 
-For 14 integer array as the key, double precision floating point as the value, 10M entries:
+* `HASH_FUNC`, which takes a key and returns a hash integer. There are defaults for integers and integer arrays;
+
+* `VALUE_POINTER`: when defined the values are assumed to be pointers.
+
+## Benchmarks
 
-Fortran hash:
+For
 
-> Insert: 1.80 s
->
-> Clean: 1.70 s
->
-> 1.59 GB
+* key: integer array of size 2;
 
-GCC unordered_map:
+* value: double precision (64-bit) floating point;
 
-> Insert: 2.02 s
-> 
-> Clean: 0.61 s
-> 
-> 1.38 GB
+* 10M entries,
 
-For 2 integer array as the key, double precision floating point as the value, 20M entries:
+on
 
-Fortran hash:
+* Intel(R) Core(TM) i7-6820HQ CPU @ 2.70GHz;
 
-> Insert: 2.66 s
-> 
-> Clean: 2.54 s
-> 
-> 2.57 GB
+* Ubuntu 20.04.3 LTS,
 
-GCC unordered_map:
+I got
 
-> Insert: 3.60 s
-> 
-> Clean: 1.07 s
-> 
-> 2.16 GB
+|           |               | ifort 2021 | gfortran 9 |
+|-----------|---------------|------------|------------|
+| *insert*  | **fhash**     | 2.99       | 2.38       |
+|           | **C++ (STL)** | 2.80       | 2.69       |
+| *clear*   | **fhash**     | 1.24       | 0.391      |
+|           | **C++ (STL)** | 0.37       | 0.328      |

benchmark.cc

@@ -1,38 +1,46 @@
 #include <boost/functional/hash.hpp>
-#include <cstdio>
-#include <cstdlib>
+#include <iostream>
 #include <ctime>
 #include <unordered_map>
-#include <vector>
 
-#define N_INTS 2
-#define N_KEYS 20000000
+constexpr int N_INTS = 2;
+constexpr int N_KEYS = 1e7;
+
+int main() {
+  std::cout << "Start C++ STL benchmark:\n";
+
+  typedef std::array<int, N_INTS> KeyType;
+  std::unordered_map<std::array<int, N_INTS>, double, boost::hash<KeyType>> h;
 
-void benchmark() {
-  typedef std::vector<int> KeyType;
-  const std::clock_t start = std::clock();
-  std::unordered_map<KeyType, double, boost::hash<KeyType>> h;
   h.reserve(N_KEYS * 2);
-  KeyType key(N_INTS);
+  const double t0 = std::clock();
+
+  KeyType key;
   for (int i = 1; i <= N_KEYS; i++) {
     for (int j = 1; j <= N_INTS; j++) {
       key[j - 1] = i + j;
     }
     h[key] = i * 0.5;
   }
-  const std::clock_t finish = std::clock();
-  printf("Time insert: %.3g s\n",
-         static_cast<double>(finish - start) / CLOCKS_PER_SEC);
+  const double t1 = std::clock();
+
+  double val;
+  for (int i = 1; i <= N_KEYS; i++) {
+    for (int j = 1; j <= N_INTS; j++) {
+      key[j - 1] = i + j;
+    }
+    val = h[key];
+  }
+  const double t2 = std::clock();
+
   h.clear();
-}
+  const double t3 = std::clock();
 
-int main() {
-  typedef std::vector<int> KeyType;
-  const std::clock_t start = std::clock();
-  benchmark();
-  const std::clock_t finish = std::clock();
-  printf("Time finish: %.3g s\n",
-         static_cast<double>(finish - start) / CLOCKS_PER_SEC);
+  std::cout << "Time to assemble / get / clear:"
+      << "       " << (t1 - t0) / CLOCKS_PER_SEC
+      << "       " << (t2 - t1) / CLOCKS_PER_SEC
+      << "       " << (t3 - t2) / CLOCKS_PER_SEC
+      << "\n";
 
   return 0;
-}
+}

benchmark.f90

@@ -0,0 +1,55 @@
+#define KEY_ARRAY_SIZE 2
+
+#define FHASH_NAME int2real
+#define KEY_TYPE integer, dimension(KEY_ARRAY_SIZE)
+#define VALUE_TYPE real(real64)
+#define VALUE_USE use, intrinsic :: iso_fortran_env, only: real64
+#include "fhash.f90"
+
+program test_benchmark
+  implicit none
+
+  call benchmark(n_ints=KEY_ARRAY_SIZE, n_keys=10**7)
+
+contains
+  subroutine benchmark(n_ints, n_keys)
+    use int2real_mod
+    use iso_fortran_env, only: real64
+
+    integer, intent(in) :: n_ints, n_keys
+
+    type(int2real_t) :: h
+    integer :: key(n_ints)
+    integer :: i, j
+    real :: t0, t1, t2, t3
+    real(real64), pointer :: val
+
+    write(*,'(a)') "Start fhash benchmark:"
+
+    write(*,'("n_ints: ", I0, ", n_keys: ", I0)') n_ints, n_keys
+
+    call h%reserve(n_keys * 2)
+    call cpu_time(t0)
+
+    do i = 1, n_keys
+      do j = 1, n_ints
+        key(j) = i + j
+      enddo
+      call h%set(key, i * 0.5d0)
+    enddo
+    call cpu_time(t1)
+
+    do i = 1, n_keys
+      do j = 1, n_ints
+        key(j) = i + j
+      enddo
+      val => h%get_ptr(key) ! , autoval=3.0_real64)
+    enddo
+    call cpu_time(t2)
+
+    call h%clear()
+    call cpu_time(t3)
+
+    write(*,'(a,3(g15.3))') "Time to assemble/ get / clear: ", t1 - t0, t2 - t1, t3 - t2
+  end subroutine
+end program