复用张量释放后的空间，生成推理内存布局

938void ExecutionFrame::TraceAllocate(int ort_value_idx, size_t size) {939  if (planner_.has_value()) {940    // don't trace the output tensors or external outputs.941    auto& allocation_plan = GetAllocationPlan(ort_value_idx);942    if (allocation_plan.alloc_kind == AllocKind::kAllocateOutput ||943        allocation_plan.alloc_kind == AllocKind::kAllocatedExternally) {944      return;945    }946    auto status = planner_->TraceAllocation(ort_value_idx, size);947    if (!status.IsOK()) {948      LOGS(session_state_.Logger(), WARNING) << "TraceAllocation for ort_value_idx=" << ort_value_idx949                                             << " size=" << size << " failed: " << status.ErrorMessage();950    }951  }952}

148    for (auto it = blocks_.begin(); it != blocks_.end(); it++) {149      if (allocs_[*it].block_.offset_ >= current) {150        auto gap = allocs_[*it].block_.offset_ - current;151        if (gap >= size && (gap - size) < waste_bytes) {152          waste_bytes = gap - size;153          best_offset = current;154          best_offset_found = true;155        }156      }157      current = std::max(current, allocs_[*it].block_.offset_ + allocs_[*it].block_.size_);158    }159160    ORT_ENFORCE(current <= buffer_size_);161162    if (current < buffer_size_) {163      auto gap = buffer_size_ - current;164      if ((gap >= size) && ((gap - size) < waste_bytes)) {165        best_offset = current;166        best_offset_found = true;167      }168    }

170    if (!best_offset_found) {171      best_offset = current;172    }173174    // we only need to bounds check the addition of size to best_offset as that is the only time we extend175    // the maximum size of the buffer.176    buffer_size_ = std::max(buffer_size_, SafeInt<size_t>(best_offset) + size);177    allocs_.emplace_back(ml_value_idx, MemoryBlock(best_offset, size));178    std::list<int>::iterator best_fit_it = blocks_.end();179    for (auto it = blocks_.begin(); it != blocks_.end(); it++) {180      if (allocs_[*it].block_.offset_ < best_offset)181        continue;182183      if ((allocs_[*it].block_.offset_ > best_offset) || (allocs_[*it].block_.size_ >= size)) {184        best_fit_it = it;185        break;186      }187    }188189    blocks_.insert(best_fit_it, (static_cast<int>(allocs_.size()) - 1));

192  void TraceFree(int ml_value_index) {193    std::lock_guard<std::mutex> lock(lock_);194195    for (auto it = blocks_.begin(); it != blocks_.end(); it++) {196      if (allocs_[*it].index_ == ml_value_index) {197        blocks_.erase(it);198        break;199      }200    }201  }

236    MemoryPattern pattern;237    pattern.peak_size_ = buffer_size_;238    pattern.patterns_.reserve(allocs_.size());239    for (auto& alloc : allocs_) {240      pattern.patterns_.insert_or_assign(alloc.index_, alloc.block_);241    }242243    return pattern;244  }

575  if (mem_patterns_ && per_alloc_plan.alloc_kind != AllocKind::kAllocateOutput &&576      per_alloc_plan.alloc_kind != AllocKind::kAllocatedExternally) {577    auto pattern = mem_patterns_->GetPatterns(location);578    if (pattern) {579      auto block = pattern->GetBlock(ort_value_index);580      // if block not found, fall back to default behavior581      if (block) {582        auto it = buffers_.find(location);583        if (it != buffers_.end()) {584          // if the block is not correct, log message then fall back to default behavior585          if (block->size_ == size) {586            void* buffer = it->second.get();587            auto status = AllocateTensorWithPreAllocateBufferHelper(588                ort_value, static_cast<void*>(static_cast<char*>(buffer) + block->offset_), element_type, location,589                shape);590            return status;591          } else {