Recover some of the performance lost after moving into state obj

9d8aa11
regressed performance noticeably. The biggest problem was way too much
accidental memset'ing of the heap, but the meat of the change that moved
state from file local statics into a single global object also seems to
hurt.

I briefly investigated whether simply /GL+/LTCG would recover the
difference, but it does not.

Before combining:
/Ox: 2.8s
/Ox /GL: 2.35s

After combining:
/Ox: 3.2s
/Ox /GL: 2.75s

That is, /GL can make up for what was lost, but it also makes the
non-combined version faster too.

This change fixes the memset bug, but the next step is to revert this
one and its predecessor (the state combining change), and work on
getting a better (longer running) benchmark. Then we can go back to
figuring out the embedding/error reporting situation with that
available.

Author: sgraham

alloc.c

@@ -28,6 +28,9 @@ void __asan_unpoison_memory_region(void const volatile* addr, size_t size);
 CompilerState compiler_state;
 LinkerState linker_state;
 
+#define C(x) compiler_state.alloc__##x
+#define L(x) linker_state.alloc__##x
+
 // Reports an error and exit.
 void error(char* fmt, ...) {
   va_list ap;
@@ -37,50 +40,32 @@ void error(char* fmt, ...) {
   exit(1);
 }
 
-#define ALLOC_INIT(state)                                                      \
-  do {                                                                         \
-    ASAN_UNPOISON_MEMORY_REGION(state.alloc__heap, sizeof(state.alloc__heap)); \
-    memset(&state, 0, sizeof(state));                                          \
-    state.alloc__current_alloc_pointer = state.alloc__heap;                    \
-    ASAN_POISON_MEMORY_REGION(state.alloc__heap, sizeof(state.alloc__heap));   \
-  } while (0)
-
-// This 0xdd fill could be debug-only.
-#define ALLOC_RESET(state)                                                     \
-  do {                                                                         \
-    ASAN_UNPOISON_MEMORY_REGION(state.alloc__heap, sizeof(state.alloc__heap)); \
-    memset(&state, 0xdd, sizeof(state));                                       \
-    state.alloc__current_alloc_pointer = NULL;                                 \
-    ASAN_POISON_MEMORY_REGION(state.alloc__heap, sizeof(state.alloc__heap));   \
-  } while (0)
-
-#define ALLOC_BUMP(ret, state)                                                                \
-  do {                                                                                        \
-    ret = state.alloc__current_alloc_pointer;                                                 \
-    state.alloc__current_alloc_pointer += toalloc;                                            \
-    if (state.alloc__current_alloc_pointer > state.alloc__heap + sizeof(state.alloc__heap)) { \
-      error("heap exhausted");                                                                \
-    }                                                                                         \
-  } while (0)
-
 void alloc_init(AllocLifetime lifetime) {
   assert(lifetime < NUM_BUMP_HEAPS);
-  if (lifetime == AL_Compile)
-    ALLOC_INIT(compiler_state);
-  else if (lifetime == AL_Link)
-    ALLOC_INIT(linker_state);
-  else
+  if (lifetime == AL_Compile) {
+    memset(&compiler_state, 0, offsetof(CompilerState, alloc__heap));
+    C(current_alloc_pointer) = C(heap);
+    ASAN_POISON_MEMORY_REGION(C(heap), sizeof(C(heap)));
+  } else if (lifetime == AL_Link) {
+    memset(&linker_state, 0, offsetof(LinkerState, alloc__heap));
+    L(current_alloc_pointer) = L(heap);
+    ASAN_POISON_MEMORY_REGION(L(heap), sizeof(L(heap)));
+  } else {
     unreachable();
+  }
 }
 
 void alloc_reset(AllocLifetime lifetime) {
   assert(lifetime < NUM_BUMP_HEAPS);
-  if (lifetime == AL_Compile)
-    ALLOC_RESET(compiler_state);
-  else if (lifetime == AL_Link)
-    ALLOC_RESET(linker_state);
-  else
+  if (lifetime == AL_Compile) {
+    C(current_alloc_pointer) = NULL;
+    ASAN_POISON_MEMORY_REGION(C(heap), sizeof(C(heap)));
+  } else if (lifetime == AL_Link) {
+    L(current_alloc_pointer) = NULL;
+    ASAN_POISON_MEMORY_REGION(L(heap), sizeof(L(heap)));
+  } else {
     unreachable();
+  }
 }
 
 void* bumpcalloc(size_t num, size_t size, AllocLifetime lifetime) {
@@ -91,14 +76,24 @@ void* bumpcalloc(size_t num, size_t size, AllocLifetime lifetime) {
   assert(lifetime < NUM_BUMP_HEAPS);
   size_t toalloc = align_to_u(num * size, 8);
   char* ret;
-  if (lifetime == AL_Compile)
-    ALLOC_BUMP(ret, compiler_state);
-  else if (lifetime == AL_Link)
-    ALLOC_BUMP(ret, linker_state);
-  else
+  if (lifetime == AL_Compile) {
+    ret = C(current_alloc_pointer);
+    C(current_alloc_pointer) += toalloc;
+    if (C(current_alloc_pointer) > C(heap) + sizeof(C(heap))) {
+      error("heap exhausted");
+    }
+  } else if (lifetime == AL_Link) {
+    ret = L(current_alloc_pointer);
+    L(current_alloc_pointer) += toalloc;
+    if (L(current_alloc_pointer) > L(heap) + sizeof(L(heap))) {
+      error("heap exhausted");
+    }
+  } else {
     unreachable();
+  }
 
   ASAN_UNPOISON_MEMORY_REGION(ret, toalloc);
+  memset(ret, 0, toalloc);
 
   return ret;
 }

makefile.win

@@ -3,7 +3,7 @@
 SRCS=$(SRCS) codegen.win32.c
 
 CC=@cl
-CFLAGS=/nologo /Od /Zi /D_CRT_SECURE_NO_DEPRECATE /DX64WIN=1 /W4 /WX
+CFLAGS=/nologo /Ox /Zi /D_CRT_SECURE_NO_DEPRECATE /DX64WIN=1 /W4 /WX
 #CC=@"C:\Program Files\LLVM\bin\clang-cl.exe"
 #CFLAGS=/nologo /O1 /fsanitize=address /Zi /D_CRT_SECURE_NO_DEPRECATE /DX64WIN=1 /W4 /WX -Wno-missing-field-initializers -Wno-switch