Optimize by speed

4 files changed, 35 insertions, 33 deletions

diff --git a/.gitignore b/.gitignore
index 332dc62..ae43fdb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,5 +7,6 @@
 *.txt
 *.trace
 *.log
+prof_output
 cmake[-_]build*/
 compile_commands.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 198fa27..dfb8f08 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,12 +8,19 @@ set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_EXPORT_COMPILE_COMMANDS True)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -pedantic")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer -O1")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types -Wall -Wextra -pedantic")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -fno-rtti") # Speed up compilation
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer -O1")
-set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer")
+set(common_flags)
+set(common_debug_flags "-fsanitize=address -fno-omit-frame-pointer -O1")
+# Uncomment to enalbe profiler
+set(common_debug_flags "${common_debug_flags} -pg")
+set(common_compile_flags "-Wall -Wextra -pedantic")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${common_compile_flags} ${common_flags}")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${common_debug_flags}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${common_compile_flags} ${common_flags}")
+# Speed up compilation with -fno-exceptions and -fno-rtti
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions -fno-rtti -Wno-nested-anon-types")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${common_debug_flags}")
+set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} ${common_flags}")
+set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} ${common_debug_flags}")
 
 set(m68kdisasm_sources
     main.cpp
diff --git a/common.h b/common.h
index ab7a359..315946f 100644
--- a/common.h
+++ b/common.h
@@ -1,6 +1,8 @@
 #pragma once
 
 constexpr size_t kInstructionSizeStepBytes = 2;
+constexpr size_t kRomSizeBytes = 4 * 1024 * 1024;
+constexpr size_t kDisasmMapSizeElements = kRomSizeBytes / kInstructionSizeStepBytes;
 
 static inline size_t Min(size_t a, size_t b) { return a < b ? a : b; }
 
diff --git a/main.cpp b/main.cpp
index 393ce00..348be93 100644
--- a/main.cpp
+++ b/main.cpp
@@ -37,7 +37,6 @@ enum class TracedNodeType {
 };
 
 struct DisasmNode {
-    DisasmNode *next{}; // Next node in the linked list
     TracedNodeType type{};
     uint32_t offset{};
     size_t size{kInstructionSizeStepBytes};
@@ -71,8 +70,7 @@ DisasmNode::~DisasmNode()
 }
 
 class DisasmMap {
-    DisasmNode *_first{};
-    DisasmNode *_last{};
+    DisasmNode *_map[kDisasmMapSizeElements]{};
     DisasmNode *findNodeByOffset(uint32_t offset) const;
 public:
     const DisasmNode *FindNodeByOffset(uint32_t offset) const
@@ -89,9 +87,8 @@ public:
 
 DisasmNode *DisasmMap::findNodeByOffset(uint32_t offset) const
 {
-    for (DisasmNode *node{_first}; node; node = node->next)
-        if (node->offset == offset)
-            return node;
+    if (offset < kRomSizeBytes)
+        return _map[offset / kInstructionSizeStepBytes];
     return nullptr;
 }
 
@@ -99,35 +96,28 @@ bool DisasmMap::InsertTracedNode(uint32_t offset, TracedNodeType type)
 {
     if (findNodeByOffset(offset))
         return false;
-    auto *node = new DisasmNode(DisasmNode{nullptr, type, offset});
+    auto *node = new DisasmNode(DisasmNode{type, offset});
     assert(node);
-    if (_first) {
-        _last->next = node;
-        _last = node;
-    } else {
-        _first = node;
-        _last = node;
-    }
+    _map[offset / kInstructionSizeStepBytes] = node;
     return true;
 }
 
 void DisasmMap::DisasmAll(const DataBuffer &code)
 {
-    for (DisasmNode *node{_first}; node; node = node->next) {
-        node->Disasm(code);
+    for (size_t i = 0; i < kDisasmMapSizeElements; i++) {
+        auto *node = _map[i];
+        if (node) {
+            _map[i]->Disasm(code);
+        }
     }
 }
 
 DisasmMap::~DisasmMap()
 {
-    DisasmNode *prev = nullptr, *node = _first;
-    while (node) {
-        prev = node;
-        node = node->next;
-        delete prev;
+    for (size_t i = 0; i < kDisasmMapSizeElements; i++) {
+        delete _map[i];
+        _map[i] = nullptr;
     }
-    _first = nullptr;
-    _last = nullptr;
 }
 
 static void RenderDisassembly(FILE *output, const DisasmMap &disasm_map, const DataBuffer &code)
@@ -220,12 +210,14 @@ static int M68kDisasmByTrace(FILE *input_stream, FILE *output_stream, FILE *trac
         return EXIT_FAILURE;
     }
     // Parse trace file into map
-    DisasmMap disasm_map{};
-    ParseTraceData(disasm_map, trace_data);
+    DisasmMap *disasm_map = new DisasmMap{};
+    assert(disasm_map);
+    ParseTraceData(*disasm_map, trace_data);
     // Disasm into output map
-    disasm_map.DisasmAll(code);
+    disasm_map->DisasmAll(code);
     // Print output into output_stream
-    RenderDisassembly(output_stream, disasm_map, code);
+    RenderDisassembly(output_stream, *disasm_map, code);
+    delete disasm_map;
     return 0;
 }