void MemDPI()

in src/dpi/module.cc [373:433]
52 lines of code
5 McCabe index (conditional complexity)

  void MemDPI(
      dpi8_t rd_req_valid,
      dpi8_t rd_req_len,
      dpi8_t rd_req_id,
      dpi64_t rd_req_addr,
      dpi8_t wr_req_valid,
      dpi8_t wr_req_len,
      dpi64_t wr_req_addr,
      dpi8_t wr_valid,
      const svOpenArrayHandle wr_value,
      dpi64_t wr_strb,
      dpi8_t* rd_valid,
      dpi8_t*  rd_id,
      const svOpenArrayHandle rd_value,
      dpi8_t rd_ready) {
    
    // check data pointers
    // data is expected to come in 64bit chunks
    // up to 512 bits total
    // more bits require wider strb data
    assert(wr_value != NULL);
    assert(svDimensions(wr_value) == 1);
    assert(svSize(wr_value, 1) <= 8);
    assert(svSize(wr_value, 0) == 64);
    assert(rd_value != NULL);
    assert(svDimensions(rd_value) == 1);
    assert(svSize(rd_value, 1) <= 8);
    assert(svSize(rd_value, 0) == 64);
    
    int lftIdx = svLeft(rd_value, 1);
    int rgtIdx = svRight(rd_value, 1);
    int blkNb  = lftIdx - rgtIdx + 1;
    assert(lftIdx >= 0);
    assert(rgtIdx >= 0);
    assert(lftIdx >= rgtIdx);
    assert(blkNb > 0);

    if (wr_valid) {
      mem_device_.WriteData(wr_value, wr_strb);
    }
    if (rd_req_valid || wr_req_valid) {
     mem_device_.SetRequest(
       rd_req_valid,
       rd_req_addr,
       rd_req_len,
       rd_req_id,
       wr_req_addr,
       wr_req_len,
       wr_req_valid);
    }

    
    MemResponse r = mem_device_.ReadData(rd_ready, blkNb);
    *rd_valid = r.valid;
    for (int idx = 0; idx < blkNb; idx ++) {
      uint64_t* dataPtr = (uint64_t*)svGetArrElemPtr1(rd_value, rgtIdx + idx);
      assert(dataPtr != NULL);
      (*dataPtr) = r.value[idx];
    }
    *rd_id     = r.id;
  }