remove preemption scratchpad from .pad

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

Author: HimanshuChoudhary-Xilinx

src/cpp/common/assembler_state.h

@@ -115,6 +115,7 @@ class assembler_state : public std::enable_shared_from_this<assembler_state>
   std::vector<std::string> m_labellist;
   std::map<std::string, std::vector<std::string>> m_dependent_labelmap;
   std::set<std::string> m_opt_opcodes;
+  bool m_is_save_restore_op = false;  // True when currently serializing a save/restore op
   inline std::string gen_label_name(bool makeunique, const std::shared_ptr<asm_data> data)
   {
     return makeunique ? data->get_qualify_op_name() : data->get_operation().get_name();
@@ -163,6 +164,7 @@ class assembler_state : public std::enable_shared_from_this<assembler_state>
   bool m_merged_ctrltext_elf = false;
 
   HEADER_ACCESS_GET_SET(offset_type, pos);
+  HEADER_ACCESS_GET_SET(bool, is_save_restore_op);
 
   void printstate() const;
 

src/cpp/encoder/aie2ps/aie2ps_encoder.cpp

@@ -12,24 +12,6 @@
 
 namespace aiebu {
 
-void
-aie2ps_encoder::
-fill_scratchpad(std::shared_ptr<section_writer> padwriter, const std::map<std::string, std::shared_ptr<scratchpad_info>>& scratchpads)
-{
-  for (const auto& pad : scratchpads)
-  {
-    const auto& content = pad.second->get_content();
-    if (content.size())
-    {
-      assert((void("Pad content size and size doesnt match\n"), content.size() == pad.second->get_size()));
-      padwriter->write_bytes(content);
-    } else {
-      auto size = pad.second->get_size();
-      padwriter->write_default_bytes(size);
-    }
-  }
-}
-
 void
 aie2ps_encoder::
 fill_controlpkt(std::shared_ptr<section_writer> ctrlpktwriter, const std::vector<char>& ctrlpkt)
@@ -107,12 +89,6 @@ process(std::shared_ptr<preprocessed_output> input)
                     optimizatiom_level, nullptr, nullptr);
     }
 
-    if (coldata.second->m_scratchpad.size()) {
-      auto padwriter = std::make_shared<section_writer>(get_PadSectionName(colnum), code_section::data);
-      fill_scratchpad(padwriter, coldata.second->m_scratchpad);
-      twriter.push_back(padwriter);
-    }
-
     for (const auto& pair : ctrlpkt_id_map) {
       auto ctrlpktwriter = std::make_shared<section_writer>(pair.second, code_section::data);
       fill_controlpkt(ctrlpktwriter, ctrlpkt[pair.second]);
@@ -244,6 +220,7 @@ page_writer(page& lpage, std::map<std::string, std::shared_ptr<scratchpad_info>>
     if (text->isOpcode())
     {
       page_state->set_pos(textwriter->tell() - text_base);
+      page_state->set_is_save_restore_op(text->get_is_save_restore());  // Track if this is save/restore op
       std::vector<uint8_t> ret = (*m_isa)[name]->serializer(args)
                                                ->serialize(page_state, tsym, colnum, pagenum);
       textwriter->write_bytes(ret);
@@ -324,6 +301,12 @@ patch57(const std::shared_ptr<section_writer> textwriter, std::shared_ptr<sectio
   uint64_t bd2 = datawriter->read_word(offset + 2*4); // NOLINT
   uint64_t bd8 = datawriter->read_word(offset + 8*4); // NOLINT
   uint64_t arg = ((bd8 & 0x1FF) << 48) + ((bd2 & 0xFFFF) << 32) + (bd1 & 0xFFFFFFFF); // NOLINT
+  // Add log for debugging patching
+  log_info() << "aie2ps_encoder::patch57: offset=" << offset
+             << ", patch=0x" << std::hex << patch
+             << ", arg=0x" << std::hex << arg
+             << ", after patch=0x" << std::hex << patch + arg
+             << std::dec << std::endl;
   patch = arg + patch;
   datawriter->write_word_at(offset + 1*4, patch & 0xFFFFFFFF); // NOLINT
   datawriter->write_word_at(offset + 2*4, ((patch >> 32) & 0xFFFF) | (bd2 & 0xFFFF0000)); // NOLINT

src/cpp/encoder/aie4/aie4_encoder.h

@@ -10,6 +10,7 @@
 #include "writer.h"
 #include "aie2ps_preprocessed_output.h"
 #include "ops.h"
+#include "common/logger.h"
 #include "specification/aie2ps/isa.h"
 
 namespace aiebu {
@@ -40,6 +41,13 @@ class aie4_encoder : public aie2ps_encoder
     uint64_t bd0 = datawriter->read_word(offset);
     uint64_t bd1 = datawriter->read_word(offset + 1*4);             // NOLINT
     uint64_t arg = (bd1 & 0xFFFFFFFF) + ((bd0 & 0x1FFFFFF) << 32); // NOLINT
+
+    // Add log for debugging patching
+    log_info() << "aie4_encoder::patch57: offset=" << offset
+               << ", patch=0x" << std::hex << patch
+               << ", arg=0x" << std::hex << arg
+               << ", after patch=0x" << std::hex << patch + arg
+               << std::dec << std::endl;
     patch = arg + patch;
     datawriter->write_word_at(offset + 1*4, patch & 0xFFFFFFFF);    // NOLINT
     datawriter->write_word_at(offset, (((patch >> 32) & 0x1FFFFFF) | (bd0 & 0xFE000000)));  // NOLINT

src/cpp/ops/ops.cpp

@@ -107,6 +107,8 @@ serialize(std::shared_ptr<assembler_state> state, std::vector<symbol>& symbols,
         {
           if (state->m_ctrlpkt_id_map.find(val) != state->m_ctrlpkt_id_map.end())
             sval = state->m_ctrlpkt_id_map[val];
+          else if (val == offset_type_marker && state->get_is_save_restore_op())
+            sval = "scratch-pad-mem";  // For save/restore routine, use "scratch-pad-mem" as arg name
           else if (val == offset_type_marker)
             sval = "control-code-" + std::to_string(colnum);
 

src/cpp/preprocessor/aie2ps/aie2ps_preprocessor.h

@@ -130,11 +130,11 @@ class aie2ps_preprocessor: public preprocessor
     toutput->set_ctrlpkt_id_map(ctrlpkt_id_map);
     toutput->set_annotations(parser->get_annotations());
 
+    offset_type preemption_scratchpad = 0;
     for (auto col: collist)
     {
       std::vector<page> pages;
       uint32_t relative_page_index = 0;
-      int pad_size = 0;
       auto& label_page_index = parser->getcollabelpageindex(col);
       auto& scratchpad = parser->getcolscratchpad(col);
       auto& coldata = parser->get_col_asmdata(col);
@@ -153,10 +153,8 @@ class aie2ps_preprocessor: public preprocessor
 
       for (auto& pad : scratchpad)
       {
-        pad_size = (((pad_size + 3) >> 2) << 2); // round off to next multiple of 4
-        pad.second->set_offset(pad_size);
-        pad.second->set_base(PAGE_SIZE * relative_page_index);
-        pad_size += pad.second->get_size();
+        pad.second->set_offset(preemption_scratchpad);
+        preemption_scratchpad += pad.second->get_size();
       }
 
       toutput->set_coldata(col, pages, scratchpad, label_page_index, tinput->get_control_packet_index());

src/cpp/preprocessor/asm/asm_parser.cpp

@@ -173,14 +173,15 @@ std::vector<uint32_t>
 asm_parser::
 get_col_list()
 {
-  // get col list
+  // get col list (sorted order since unordered_map doesn't preserve insertion order)
   std::vector<uint32_t> keys;
 
   std::transform(
     m_col.begin(),
     m_col.end(),
     std::back_inserter(keys),
     [](const std::unordered_map<uint32_t, col_data>::value_type &pair){return pair.first;});
+  std::sort(keys.begin(), keys.end());
   return keys;
 }
 
@@ -303,7 +304,8 @@ parse_lines(const std::vector<char>& data, std::string& file)
       } else
         insert_col_asmdata(std::make_shared<asm_data>(operation(sm[1].str(), ""), operation_type::label,
                                                       code_section::unknown, 0, (uint32_t)-1, linenumber,
-                                                      parse_file_idx));
+                                                      parse_file_idx, is_save_restore_routine()));
+
       continue;
     }
     // check for operation
@@ -388,9 +390,10 @@ parse_lines(const std::vector<char>& data, std::string& file)
 
         line = op_name + "\t" + arg_str;
       }
+
       insert_col_asmdata(std::make_shared<asm_data>(operation(op_name, arg_str), operation_type::op,
                                                     code_section::unknown, 0, (uint32_t)-1, linenumber,
-                                                    parse_file_idx));
+                                                    parse_file_idx, is_save_restore_routine()));
       if (!op_name.compare("eof"))
         set_data_state(true);
     }
@@ -1073,12 +1076,14 @@ asm_parser::inject_hintmap_save_restore(int col,
 
   m_current_col = col;
   set_data_state(false);
+  set_save_restore_routine(true);  // Mark as save/restore routine
   parse_lines(save_chars, save_file_mod);
   pop_data_state();
 
   set_data_state(false);
   parse_lines(restore_chars, restore_file_mod);
   pop_data_state();
+  set_save_restore_routine(false);  // Clear save/restore routine flag
 }
 
 // ---------------------------------------------------------------------------
@@ -1202,12 +1207,14 @@ asm_parser::inject_default_save_restore(int col,
 
   m_current_col = col;
   set_data_state(false);
+  set_save_restore_routine(true);  // Mark as save/restore routine
   parse_lines(save_chars, save_file_mod);
   pop_data_state();
 
   set_data_state(false);
   parse_lines(restore_chars, restore_file_mod);
   pop_data_state();
+  set_save_restore_routine(false);  // Clear save/restore routine flag
 }
 
 // ---------------------------------------------------------------------------
@@ -1468,14 +1475,20 @@ operate(std::shared_ptr<asm_parser> parserptr,
 void
 pad_directive::
 operate(std::shared_ptr<asm_parser> parserptr,
-        const std::string& /*directive_line*/,
+        const std::string& directive_line,
         const std::string& args_tail)
 {
   m_parserptr = parserptr;
   verify_nonempty_args(args_tail, error::error_code::invalid_asm, ".setpad directive requires arguments\n");
 
   std::vector<std::string> args = splitoption(args_tail.c_str(), ',');
 
+  // .setpad should only be part of save/restore routines
+  if (!m_parserptr->should_skip_setpad_in_save_restore()) {
+    log_warn() << "Warning: Directive \"" << directive_line << "\" found outside save/restore routine for target: "
+               << m_parserptr->get_target_type() << "\n";
+  }
+
   add_scratchpad(args[0], args[1]);
 }
 

src/cpp/preprocessor/asm/asm_parser.h

@@ -269,6 +269,7 @@ class asm_data
   // m_file replaced with a 32-bit index into a thread_local intern table.
   uint32_t m_file_idx;
   int m_annotation_index = -1;
+  bool m_is_save_restore = false;  // True if this instruction is from save/restore routine
 
 public:
   asm_data() = default;
@@ -282,17 +283,18 @@ class asm_data
   */
   asm_data(operation op, operation_type optype,
            code_section sec, offset_type size, uint32_t pgnum,
-           uint32_t ln, uint32_t file_idx)
+           uint32_t ln, uint32_t file_idx, bool is_save_restore = false)
            :m_op(std::move(op)), m_optype(optype), m_section(sec), m_size(size),
             m_pagenum(pgnum), m_linenumber(ln),
-            m_file_idx(file_idx) {}
+            m_file_idx(file_idx), m_is_save_restore(is_save_restore) {}
 
   // Rule of Zero: implicit copy/move keeps insert_col_asmdata / vector growth cheap.
 
   HEADER_ACCESS_GET_SET(code_section, section);
   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); }
   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").
@@ -322,6 +324,7 @@ class asm_data
     return n + ' ' + a;
   }
 
+  HEADER_ACCESS_GET_SET(bool, is_save_restore);
   bool isLabel() const { return m_optype == operation_type::label; }
   bool isOpcode() const { return m_optype == operation_type::op; }
   bool isAnnotation() const { return m_optype == operation_type::annotation; }
@@ -478,6 +481,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
+  bool m_is_save_restore_routine = false;  // True when parsing save/restore routine files
 
   // One unique scratchpad region: all hintmap labels that share the same scratchbase+size
   struct hintmap_group_entry {
@@ -557,6 +561,20 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
 
   bool is_multi_column_mode() const { return m_preempt_labels.size() > 1; }
 
+  // Check if currently parsing save/restore routine
+  bool is_save_restore_routine() const { return m_is_save_restore_routine; }
+  void set_save_restore_routine(bool val) { m_is_save_restore_routine = val; }
+
+  // Check if we should skip setpad for this target in save/restore routine
+  bool should_skip_setpad_in_save_restore() const {
+    return m_is_save_restore_routine;
+  }
+
+  // Check if we should use scratch-pad section for save/restore APPLY_OFFSET_57
+  //bool should_use_scratchpad_section_for_save_restore() const {
+  //  return m_is_save_restore_routine;
+  //}
+
   // Record preempt label for current group (called when PREEMPT opcode is hit)
   // Label naming: save_N / restore_N where N = index (group/2 + 1)
   // group 0 -> save_1, group 2 -> save_2, group 4 -> save_3

test/aie4-ctrlcode/1col_preempt/gold.md5

@@ -1 +1 @@
-58f4172515858e1c790a38aab7bfa6b9
+36b5e14897a92d5f0c2c1ae965ffc8e7

test/aie4-ctrlcode/1col_preempt/gold_target.md5

@@ -1 +1 @@
-7f27c182bdcad298d09f563cea160922
+71abde9f51feb4706acbe8f56ede9787