review comment

Signed-off-by: Himanshu Choudhary <Himanshu.Choudhary@amd.com>

Author: HimanshuChoudhary-Xilinx

src/cpp/encoder/aie2ps/aie2ps_encoder.cpp

@@ -60,6 +60,7 @@ process(std::shared_ptr<preprocessed_output> input)
   auto& totalcoldata = tinput->get_coldata();
   auto& totalsyms = tinput->get_symbols();
   m_debug.set_annotations(tinput->get_annotations());
+  m_debug.set_filename_table(tinput->get_filename_table());
   uint32_t optimizatiom_level = tinput->get_optimization_level();
   auto& ctrlpkt = tinput->get_ctrlpkt();
   auto& ctrlpkt_id_map = tinput->get_ctrlpkt_id_map();

src/cpp/encoder/aie2ps/report.h

@@ -62,24 +62,27 @@ class Function {
 
   // Takes a file index instead of the filename
   // string, avoiding a heap allocation per Function object.
-  Function(uint32_t file_idx, const std::string& name, offset_type high_pc, offset_type low_pc, uint32_t col, pageid_type pagenum)
-        : m_file_idx(file_idx), m_name(name), m_colnum(col), m_pagenum(pagenum), m_highpc(high_pc), m_lowpc(low_pc) {}
+  Function(std::shared_ptr<const detail::filename_table> filename_table,
+           uint32_t file_idx, const std::string& name, offset_type high_pc, offset_type low_pc,
+           uint32_t col, pageid_type pagenum)
+        : m_filename_table(std::move(filename_table)), m_file_idx(file_idx), m_name(name),
+          m_colnum(col), m_pagenum(pagenum), m_highpc(high_pc), m_lowpc(low_pc) {}
 
   void add_textline(std::shared_ptr<Line> line) { m_textlines.push_back(std::move(line)); }
   void add_dataline(std::shared_ptr<Line> line) { m_datalines.push_back(std::move(line)); }
 
   const std::vector<std::shared_ptr<Line>>& get_textlines() const { return m_textlines; }
   const std::vector<std::shared_ptr<Line>>& get_datalines() const { return m_datalines; }
 
-  // Looks up the filename string on demand from the intern table.
-  const std::string& get_filename() const { return detail::lookup_filename(m_file_idx); }
+  const std::string& get_filename() const { return m_filename_table->lookup_filename(m_file_idx); }
   const std::string& get_name() const { return m_name; }
   uint32_t get_column() const { return m_colnum; }
   pageid_type get_pagenum() const { return m_pagenum; }
   offset_type get_highPc() const { return m_highpc; }
   offset_type get_lowPc() const { return m_lowpc; }
 
 private:
+  std::shared_ptr<const detail::filename_table> m_filename_table;
   uint32_t m_file_idx;
   std::string m_name;
   uint32_t m_colnum;
@@ -95,11 +98,15 @@ class Debug {
     m_annotation_list = std::move(annotations);
   }
 
+  void set_filename_table(std::shared_ptr<const detail::filename_table> table) {
+    m_filename_table = std::move(table);
+  }
+
   std::string add_function(uint32_t file_idx, const std::string& name, offset_type high_pc, offset_type low_pc, uint32_t col, pageid_type pagenum) {
     // source/file/column/page do not overwrite previously recorded functions.
     std::string key = std::to_string(file_idx) + "_" + std::to_string(col) + "_"
                       + std::to_string(pagenum) + "_" + name;
-    functions[key] = std::make_shared<Function>(file_idx, name, high_pc, low_pc, col, pagenum);
+    functions[key] = std::make_shared<Function>(m_filename_table, file_idx, name, high_pc, low_pc, col, pagenum);
     insertion_order.push_back(key);
     return key;
   }
@@ -135,6 +142,7 @@ class Debug {
   }
 
 private:
+  std::shared_ptr<const detail::filename_table> m_filename_table;
   std::map<std::string, std::shared_ptr<Function>> functions;
   std::vector<std::string> insertion_order;
   std::vector<annotation_type> m_annotation_list;

src/cpp/preprocessor/aie2ps/aie2ps_preprocessed_output.h

@@ -32,6 +32,7 @@ class aie2ps_preprocessed_output : public preprocessed_output
   std::shared_ptr<const aie_row_topology_info> m_aie_row_topology;
   std::map<std::string, std::vector<char>> m_ctrlpkt;
   std::map<uint32_t, std::string> m_ctrlpkt_id_map;
+  std::shared_ptr<const detail::filename_table> m_filename_table;
 public:
 
   explicit aie2ps_preprocessed_output(std::shared_ptr<const partition_info> partition,
@@ -107,6 +108,14 @@ class aie2ps_preprocessed_output : public preprocessed_output
   {
     m_ctrlpkt_id_map = ctrlpkt_id_map;
   }
+
+  void set_filename_table(std::shared_ptr<const detail::filename_table> table) {
+    m_filename_table = std::move(table);
+  }
+
+  const std::shared_ptr<const detail::filename_table>& get_filename_table() const {
+    return m_filename_table;
+  }
 };
 
 template <typename T>

src/cpp/preprocessor/aie2ps/aie2ps_preprocessor.h

@@ -182,6 +182,8 @@ class aie2ps_preprocessor: public preprocessor
     toutput->set_ctrlpkt(controlpkts);
     toutput->set_ctrlpkt_id_map(ctrlpkt_id_map);
     toutput->set_annotations(parser->get_annotations());
+    toutput->set_filename_table(
+        std::make_shared<detail::filename_table>(parser->get_filename_table()));
 
     for (auto col: collist)
     {
@@ -198,7 +200,7 @@ class aie2ps_preprocessor: public preprocessor
         std::vector<std::shared_ptr<asm_data>> data = coldata.get_label_asmdata(label);
         std::shared_ptr<assembler_state> state = create_assembler_state(m_isa, data, scratchpad, label_page_index, ctrlpkt_id_map, optimize, true);
       // create pages
-        pager(PAGE_SIZE).pagify(*state, col, pages, relative_page_index);
+        pager(PAGE_SIZE, parser->default_source_file_idx()).pagify(*state, col, pages, relative_page_index);
         label_page_index[get_pagelabel(label)] = relative_page_index;
         log_debug() << "num pages: " << pages.size() - relative_page_index << std::endl;
         relative_page_index = static_cast<uint32_t>(pages.size());

src/cpp/preprocessor/asm/asm_parser.cpp

@@ -354,7 +354,7 @@ parse_lines(const std::vector<char>& data, std::string& file)
       str += c;
     }
   }
-  const uint32_t parse_file_idx = detail::intern_filename(file);
+  const uint32_t parse_file_idx = intern_filename(file);
   // Scan str for newlines directly instead of copying it into an istringstream
   size_t pos = 0;
   const size_t str_len = str.size();
@@ -1397,7 +1397,7 @@ operate(std::shared_ptr<asm_parser> parserptr,
   // dummy eof added if col change happens before eof
   m_parserptr->insert_col_asmdata(std::make_shared<asm_data>(operation("eof", ""),
                                                               operation_type::op, code_section::unknown, 0,
-                                                              (uint32_t)-1, 0, detail::default_source_file_idx()));
+                                                              (uint32_t)-1, 0, m_parserptr->default_source_file_idx()));
   m_parserptr->set_current_col(std::stoi(args_tail));
   m_parserptr->set_data_state(false);
 }
@@ -1511,7 +1511,7 @@ bool
 include_directive::
 read_include_file(std::string filename)
 {
-  if (!m_parserptr->add_seen_file(filename))
+  if (m_parserptr->is_filename_seen(filename))
     throw error(error::error_code::invalid_input,
                 "duplicate asm file name \"" + filename + "\"");
   m_parserptr->set_data_state(false);

src/cpp/preprocessor/asm/asm_parser.h

@@ -226,36 +226,39 @@ class aie_row_topology_directive: public directive
   aie_row_topology_directive& operator=(aie_row_topology_directive&&) = default;
 };
 
-// Filename intern table: maps each unique source-file name to a compact 32-bit index.
-// thread_local: It means each thread gets its own separate copy of the table,
-// which keeps concurrent parse jobs on different threads isolated.
-// The table is never cleared; indices remain valid as long as the thread is alive,
-// which always outlives any asm_data objects created on that thread.
-// inline: This global variable can be defined in multiple translation units without
-// violating the One Definition Rule (ODR).
+// Per-parser filename intern table: maps each unique source-file name to a compact
+// 32-bit index. One table per asm_parser so config.json instances do not share indices.
 namespace detail {
-  inline thread_local std::vector<std::string> g_filename_table;
-  inline thread_local std::unordered_map<std::string, uint32_t> g_filename_index;
+class filename_table {
+  std::vector<std::string> m_table;
+  std::unordered_map<std::string, uint32_t> m_index;
+  uint32_t m_default_idx = static_cast<uint32_t>(-1);
 
-  inline uint32_t intern_filename(const std::string& fname) {
-    auto it = g_filename_index.find(fname);
-    if (it != g_filename_index.end())
+public:
+  uint32_t intern_filename(const std::string& fname) {
+    auto it = m_index.find(fname);
+    if (it != m_index.end())
       return it->second;
-    const auto idx = static_cast<uint32_t>(g_filename_table.size());
-    g_filename_table.push_back(fname);
-    g_filename_index.emplace(g_filename_table.back(), idx);
+    const auto idx = static_cast<uint32_t>(m_table.size());
+    m_table.push_back(fname);
+    m_index.emplace(m_table.back(), idx);
     return idx;
   }
 
-  inline const std::string& lookup_filename(uint32_t idx) {
-    return g_filename_table[idx];
+  const std::string& lookup_filename(uint32_t idx) const {
+    return m_table[idx];
   }
 
-  // Cached index for synthetic ops that are not tied to a real source path.
-  inline uint32_t default_source_file_idx() {
-    thread_local const uint32_t idx = intern_filename(std::string("default"));
-    return idx;
+  bool is_filename_seen(const std::string& fname) const {
+    return m_index.find(fname) != m_index.end();
+  }
+
+  uint32_t default_source_file_idx() {
+    if (m_default_idx == static_cast<uint32_t>(-1))
+      m_default_idx = intern_filename(std::string("default"));
+    return m_default_idx;
   }
+};
 } // namespace detail
 
 class asm_data
@@ -267,7 +270,7 @@ class asm_data
   pageid_type m_pagenum;
   uint32_t m_linenumber;
   // m_line removed: assembly text is reconstructed on demand via get_line().
-  // m_file replaced with a 32-bit index into a thread_local intern table.
+  // m_file replaced with a 32-bit index into the owning parser's filename_table.
   uint32_t m_file_idx;
   int m_annotation_index = -1;
 
@@ -294,7 +297,9 @@ class asm_data
   HEADER_ACCESS_GET_SET(offset_type, size);
   HEADER_ACCESS_GET_SET(pageid_type, pagenum);
   HEADER_ACCESS_GET_SET(uint32_t, linenumber);
-  const std::string& get_file() const { return detail::lookup_filename(m_file_idx); }
+  const std::string& get_file(const detail::filename_table& table) const {
+    return table.lookup_filename(m_file_idx);
+  }
   uint32_t get_file_idx() const { return m_file_idx; }
   // Qualify the operation's own name as a label-map key (e.g. "0:start_job").
   std::string get_qualify_op_name() const {
@@ -512,7 +517,7 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
   std::map<int, std::vector<std::string>> m_preempt_hintmaps;  // group -> vector of hintmap_labels (multiple PREEMPT opcodes per group)
   std::map<std::string, std::pair<std::string, std::string>> m_hintmap_labels;  // hintmap_label -> (save_label, restore_label)
   std::set<int> m_preempt_without_hintmap;  // groups that have PREEMPT opcodes without hintmaps
-  std::set<std::string> m_seen_files;  // tracks included file names to detect duplicates
+  detail::filename_table m_filename_table;
 
   // One unique scratchpad region: all hintmap labels that share the same scratchbase+size
   struct hintmap_group_entry {
@@ -768,8 +773,6 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
   std::string get_current_label() const { return m_current_label; }
   const file_artifact* get_artifacts() const { return m_artifacts;}
 
-  // Register filename as seen; returns true on first visit, false if already seen (duplicate).
-  bool add_seen_file(const std::string& filename) { return m_seen_files.insert(filename).second; }
 
   std::string top_label() const
   {
@@ -823,6 +826,20 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
 
   void set_aie_row_topology_is_set(bool val) { m_aie_row_topology->set_is_set(val); }
 
+  const detail::filename_table& get_filename_table() const { return m_filename_table; }
+
+  uint32_t intern_filename(const std::string& fname) {
+    return m_filename_table.intern_filename(fname);
+  }
+
+  bool is_filename_seen(const std::string& fname) const {
+    return m_filename_table.is_filename_seen(fname);
+  }
+
+  uint32_t default_source_file_idx() {
+    return m_filename_table.default_source_file_idx();
+  }
+
   void parse_lines();
 
   void parse_lines(const std::vector<char>& data, std::string& file);

src/cpp/preprocessor/asm/pager.cpp

@@ -318,7 +318,7 @@ assignpagenumber(assembler_state& state, uint32_t colnum,
   if (aligner)
     lpage.m_text.emplace_back(std::make_shared<asm_data>(operation(".align", "16"),
                                                     operation_type::op, code_section::text, 0,
-                                                    (uint32_t)-1, 0, detail::default_source_file_idx()));
+                                                    (uint32_t)-1, 0, m_default_file_idx));
 
   uint32_t cur_page_len = PAGE_HEADER_SIZE + tsize + EOF_SIZE + aligner + dsize;
   cur_page_len = (((cur_page_len + 3) >> 2) << 2); // round off to next multiple of 4

src/cpp/preprocessor/asm/pager.h

@@ -14,6 +14,7 @@ namespace aiebu {
 class pager
 {
   uint32_t m_page_size;
+  uint32_t m_default_file_idx;
   constexpr static offset_type PAGE_HEADER_SIZE = 16;
   constexpr static offset_type EOF_SIZE = 4;
   constexpr static offset_type DATA_SECTION_ALIGNMENT = 16;
@@ -62,7 +63,8 @@ class pager
   }
 
 public:
-  pager(uint32_t page_size): m_page_size(page_size) {}  
+  pager(uint32_t page_size, uint32_t default_file_idx)
+    : m_page_size(page_size), m_default_file_idx(default_file_idx) {}
   uint32_t pagify(assembler_state& state, uint32_t col, std::vector<page>& pages, uint32_t relative_page_index);
 };