Densify source lists, fix issues with cmuxh

Author: galibert

data/cmuxh-mux.txt

@@ -124,16 +124,15 @@ g burst_count_ctrl                 m:1 116 | 130 | 240 | 233
   0 static !
   1 core_ctrl
 g burst_count                      r-:3 129 122 136 | 117 137 123 | 232 246 226 | 241 227 247 
-X iclk_sel                         r+:5
-  * 179 193 173 187 180
-  * 194 174 188 181 195
-  * 176 183 169 189 175
-  * 160 153 167 168 182
-Y iclk_sel                         r+:5
+r iclk_sel                         r+:5
   * 33 53 40 47 39
   * 45 38 52 32 46
   * 48 41 55 56 34
   * 78 64 71 57 77
+  * 179 193 173 187 180
+  * 194 174 188 181 195
+  * 176 183 169 189 175
+  * 160 153 167 168 182
   * 316 323 309 329 330
   * 310 324 317 331 311
   * 308 307 293 300 286

generator/generator.cc

@@ -43,6 +43,7 @@ struct data_header {
   uint32_t off_ro;
   uint32_t off_roh;
   uint32_t off_ri;
+  uint32_t off_rsrc;
   uint32_t off_line;
   uint32_t off_p2r;
   uint32_t off_p2p;
@@ -56,6 +57,7 @@ struct data_header {
 
   uint32_t count_ro;
   uint32_t count_ri;
+  uint32_t count_rsrc;
   uint32_t count_p2r;
   uint32_t count_p2p;
   uint32_t count_inv;
@@ -183,6 +185,9 @@ int main(int argc, char **argv)
 
     std::vector<uint32_t> rnode_vec;
     std::vector<uint32_t> rnode_pos;
+    std::vector<uint8_t> source_patterns;
+    std::unordered_map<uint16_t, std::vector<uint32_t>> source_offsets;
+    uint32_t source_offsets_counts = 0;
 
     uint8_t *opos = output.data() + dh->off_ro;
     while(rparse.rn || lparse.rn) {
@@ -210,17 +215,57 @@ int main(int argc, char **argv)
       rb.ro_line_info_index = lv ? get_line_info(lparse.li) : 0xffff;
       rb.ro_driver_position = lv ? lparse.driver_position : 0;
       rb.ro_fw_pos = rv ? rparse.fw_pos : 0;
-
       uint32_t span = rv ? rparse.pattern == 0xfe ? 1 : rmux_patterns[rparse.pattern].span : 0;
-    
-      memcpy(opos, &rb, sizeof(rb));
+
+      uint8_t *rbpos = opos;
       opos += sizeof(rb);
 
       if(span) {
-	memcpy(opos, rparse.sources.data(), span*4);
-	opos += 4*span;
+	uint8_t srcidx[64];
+	uint8_t backidx[64];
+	uint32_t srclen = 0;
+
+	for(uint32_t i = 0; i != span; i++) {
+	  if(rparse.sources[i]) {
+	    if(i != srclen)
+	      rparse.sources[srclen] = rparse.sources[i];
+	    srcidx[srclen] = i;
+	    backidx[i] = srclen++;
+	  } else
+	    backidx[i] = 0xff;
+	}
+
+	rb.ro_span = span;
+	rb.ro_srclen = srclen;
+
+	uint16_t key = (span << 8) | srclen;
+	auto &offs = source_offsets[key];
+	for(uint32_t off : offs)
+	  if(!memcmp(source_patterns.data() + off, srcidx, srclen)) {
+	    rb.ro_srcoff = off;
+	    goto found;
+	  }
+	{
+	  uint32_t off = source_patterns.size();
+	  rb.ro_srcoff = off;
+	  source_patterns.resize(off + srclen + span);
+	  memcpy(source_patterns.data() + off, srcidx, srclen);
+	  memcpy(source_patterns.data() + off + srclen, backidx, span);
+	  offs.push_back(off);
+	  source_offsets_counts ++;
+	}
+
+      found:
+	memcpy(opos, rparse.sources.data(), srclen*4);
+	opos += 4*srclen;
+      } else {
+	rb.ro_span = 0;
+	rb.ro_srclen = 0;
+	rb.ro_srcoff = 0xffff;
       }
 
+      memcpy(rbpos, &rb, sizeof(rb));
+
       if(rb.ro_targets_count || rb.ro_targets_caps_count) {
 	memcpy(opos, lparse.targets.data(), rb.ro_targets_count*4);
 	opos += rb.ro_targets_count*4;
@@ -250,6 +295,7 @@ int main(int argc, char **argv)
     auto hdata = bdz_ph_hash::make(rnode_vec);
     size_t rohs   = (hdata.size() + 3) & ~3;
     size_t ris    = 4*bdz_ph_hash::output_range(hdata);
+    size_t rsrc   = (source_patterns.size() + 3) & ~3;
     size_t llines = sizeof(rnode_line_information)*rli_data.size();
     size_t p2rs   = p2r.data.size()*sizeof(p2r_info);
     size_t p2ps   = p2p.data.size()*sizeof(p2p_info);
@@ -263,7 +309,8 @@ int main(int argc, char **argv)
 
     dh->off_roh = opos - output.data();
     dh->off_ri = dh->off_roh + rohs;
-    dh->off_line = dh->off_ri + ris;
+    dh->off_rsrc = dh->off_ri + ris;
+    dh->off_line = dh->off_rsrc + rsrc;
     dh->off_p2r = dh->off_line + llines;
     dh->off_p2p = dh->off_p2r + p2rs;
     dh->off_inv = dh->off_p2p + p2ps;
@@ -277,6 +324,7 @@ int main(int argc, char **argv)
 
     dh->count_ro = rnode_vec.size();
     dh->count_ri = bdz_ph_hash::output_range(hdata);
+    dh->count_rsrc = source_patterns.size() ;
     dh->count_p2r = p2r.data.size();
     dh->count_p2p = p2p.data.size();
     dh->count_inv = inv.data.size();
@@ -298,6 +346,7 @@ int main(int argc, char **argv)
       ro->ro_ri = idx;
     }
 
+    memcpy(output.data() + dh->off_rsrc, source_patterns.data(), dh->count_rsrc);
     memcpy(output.data() + dh->off_line, rli_data.data(), llines);
     memcpy(output.data() + dh->off_p2r, p2r.data.data(), p2rs);
     memcpy(output.data() + dh->off_p2p, p2p.data.data(), p2ps);
@@ -310,13 +359,15 @@ int main(int argc, char **argv)
     memcpy(output.data() + dh->off_dqs16, dqs16_info.data(), dqs16s);
     memcpy(output.data() + dh->off_iob, iob.data.data(), iobs);
 
-    fprintf(stderr, "%-6s size %9d ro %9d rh %7d ri %8d rc %7d lines %5d p2r %5d p2p %4d inv %5d one %2d dcram %2d hps %2d fixed %2d dqs16 %2d iob %3d\n",
+    fprintf(stderr, "%-6s size %9d ro %9d rh %7d ri %8d rc %7d rsrc %d/%d lines %5d p2r %5d p2p %4d inv %5d one %2d dcram %2d hps %2d fixed %2d dqs16 %2d iob %3d\n",
 	    chip.c_str(),
 	    int(output.size()),
 	    dh->off_roh - dh->off_ro,
 	    dh->off_ri - dh->off_roh,
 	    dh->count_ri,
 	    dh->count_ro,
+	    source_offsets_counts,
+	    dh->count_rsrc,
 	    int(rli_data.size()),
 	    int(p2r.data.size()),
 	    int(p2p.data.size()),

generator/nodes.h

@@ -108,6 +108,9 @@ struct rnode_object {
   uint8_t ro_targets_count;
   uint8_t ro_targets_caps_count;
   uint8_t ro_drivers[2];
+  uint8_t ro_span;
+  uint8_t ro_srclen;
+  uint16_t ro_srcoff;
   uint16_t ro_line_info_index;
   uint16_t ro_driver_position;
   uint32_t ro_fw_pos;

libmistral/cv-bmux.cc

@@ -292,6 +292,8 @@ void mistral::CycloneV::bmux_val_set(uint32_t base, const bmux *mux, int idx, bm
       uint32_t pos = (base & 0xffff) + bt[0];
       if(base & (1<<23))
 	bmux_dqs16_adjust(pos, bt[0], base & (1 << 22));
+      if(pos >= prami.size())
+	abort();
       prami[pos] = b >= 64 ? 0 : (val >> b) & 1;
       bt ++;
     }

libmistral/cv-rmux.cc

@@ -49,6 +49,7 @@ void mistral::CycloneV::rmux_load()
   ro_end = reinterpret_cast<const rnode_object *>(data + dhead->off_roh);
   roh_info = data + dhead->off_roh;
   ri_info = reinterpret_cast<const uint32_t *>(data + dhead->off_ri);
+  rsrc_info = data + dhead->off_rsrc;
   rli_data = reinterpret_cast<const rnode_line_information *>(data + dhead->off_line);
   p2r_infos = reinterpret_cast<const p2r_info *>(data + dhead->off_p2r);
   p2p_infos = reinterpret_cast<const p2p_info *>(data + dhead->off_p2p);
@@ -114,7 +115,7 @@ mistral::CycloneV::rnode_coords mistral::CycloneV::rmux_get_source(const rnode_o
   int slot = rmux_get_slot(r);
   if(slot == -1)
     return rnode_coords();
-  return r.sources_begin()[slot];
+  return r.sources_begin()[r.sources_backward_mapping(rsrc_info)[slot]];
 }
 
 bool mistral::CycloneV::rnode_do_link(rnode_coords n1, rnode_coords n2)
@@ -125,9 +126,10 @@ bool mistral::CycloneV::rnode_do_link(rnode_coords n1, rnode_coords n2)
     return n1 == r->sources_begin()[0];
   const rmux_pattern &pat = rmux_patterns[r->pattern()];
   const rnode_coords *sources = r->sources_begin();
-  for(int slot = 0; slot != pat.span; slot++)
-    if(sources[slot] == n1) {
-      rmux_set_val(*r, rmux_vals[pat.o_vals + slot]);
+  const uint8_t *srcslot = r->sources_forward_mapping(rsrc_info);
+  for(uint8_t idx = 0; idx != r->sources_count(); idx++)
+    if(sources[idx] == n1) {
+      rmux_set_val(*r, rmux_vals[pat.o_vals + srcslot[idx]]);
       return true;
     }
   return false;
@@ -150,11 +152,12 @@ bool mistral::CycloneV::rmux_is_default(rnode_coords node) const
 
 void mistral::CycloneV::route_set_defaults()
 {
-  for(const auto &r : rnodes())
+  for(const auto &r : rnodes()) {
     if(r.pattern() < 0xfe) {
       const rmux_pattern &pat = rmux_patterns[r.pattern()];
       rmux_set_val(r, pat.def);
     }
+  }
 }
 
 bool mistral::CycloneV::rnode_active(const rnode_object *rn, rnode_coords previous) const

libmistral/cyclonev.cc

@@ -495,8 +495,6 @@ void mistral::CycloneV::validate_fw_bw() const
       const rnode_coords *rs = ro->sources_begin();
       for(uint32_t i=0; i != ro->sources_count(); i++) {
 	rnode_coords rns = rs[i];
-	if(!rns)
-	  continue;
 	const rnode_object *rnso = rc2ro(rns);
 	if(!rnso) {
 	  printf("%s: %s - backward node missing.\n", rn.to_string().c_str(), rns.to_string().c_str());

libmistral/cyclonev.h

@@ -442,6 +442,9 @@ namespace mistral {
       uint8_t ro_targets_count;
       uint8_t ro_targets_caps_count;
       uint8_t ro_drivers[2];
+      uint8_t ro_span;
+      uint8_t ro_srclen;
+      uint16_t ro_srcoff;
       uint16_t ro_line_info_index;
       uint16_t ro_driver_position;
       uint32_t ro_fw_pos;
@@ -451,7 +454,7 @@ namespace mistral {
       inline rnode_index  ri() const noexcept { return ro_ri; }
 
       inline uint32_t sources_count() const noexcept {
-	return ro_pattern == 0xff ? 0 : ro_pattern == 0xfe ? 1 : rmux_patterns[ro_pattern].span;
+	return ro_srclen;
       }
 
       inline const rnode_coords *sources_begin() const noexcept {
@@ -506,6 +509,20 @@ namespace mistral {
 	return ro_pattern;
       }
 
+      uint8_t sources_span() const noexcept {
+	return ro_span;
+      }
+
+      const uint8_t *sources_forward_mapping(const uint8_t *rsrc) const noexcept
+      {
+	return rsrc + ro_srcoff;
+      }
+
+      const uint8_t *sources_backward_mapping(const uint8_t *rsrc) const noexcept
+      {
+	return rsrc + ro_srcoff + ro_srclen;
+      }
+
       uint16_t line_info_index() const noexcept {
 	return ro_line_info_index;
       }
@@ -745,6 +762,7 @@ namespace mistral {
       uint32_t off_ro;
       uint32_t off_roh;
       uint32_t off_ri;
+      uint32_t off_rsrc;
       uint32_t off_line;
       uint32_t off_p2r;
       uint32_t off_p2p;
@@ -758,6 +776,7 @@ namespace mistral {
 
       uint32_t count_ro;
       uint32_t count_ri;
+      uint32_t count_rsrc;
       uint32_t count_p2r;
       uint32_t count_p2p;
       uint32_t count_inv;
@@ -943,12 +962,14 @@ namespace mistral {
     public:
       rnode_proxy(const rnode_object *_rn) : rn(_rn) {}
       rnode_coords rc() const { return rn->rc(); }
+      rnode_index ri() const { return rn->ri(); }
       int pattern() const { return rn->pattern(); }
       rnode_source_container_proxy sources() const { return rnode_source_container_proxy(rn); }
 
-    private:
       const rnode_object *rn;
 
+    private:
+
       operator const rnode_object&() const { return *rn; }
     };
 
@@ -1239,6 +1260,7 @@ namespace mistral {
     const rnode_object *ro_begin, *ro_end;
     const uint8_t *roh_info;
     const uint32_t *ri_info;
+    const uint8_t *rsrc_info;
     const rnode_line_information *rli_data;
 
     const p2r_info *p2r_infos;

tools/mux_to_source.py

@@ -227,7 +227,7 @@ def dump_muxes(name, muxes, bci, counters, filter = lambda t: True):
 hps_clocks = load_mux_data("hps_clocks", { 'i': 18 }, True)
 cmuxc      = load_mux_data("cmuxc",      { 'r': 6, 'R': 1, 'Y': 4 })
 cmuxv      = load_mux_data("cmuxv",      { 'g': 4, 'r': 20, 'G': 1, 'R': 1 })
-cmuxh      = load_mux_data("cmuxh",      { 'g': 4, 'r': 12, 'G': 1, 'R': 1, 'X': 4, 'Y': 8 })
+cmuxh      = load_mux_data("cmuxh",      { 'g': 4, 'r': 12, 'G': 1, 'R': 1 })
 dll        = load_mux_data("dll",        { 'g': 1 })
 hssi       = load_mux_data("hssi",       { 'g': 1, 'i': 3 })
 cbuf       = load_mux_data("cbuf",       { 'g': 1, 'i': 2 })