Method build_node

src/runtime/dag_builder.cpp:143–212

dag_builder::dag_builder(runtime *rt) : _rt{rt} {}

dag_node_ptr dag_builder::build_node(std::unique_ptr<operation> op,
                                     const requirements_list& requirements,
                                     const execution_hints& hints)
{
  assert(op);

  // Calculate additional requirements:
  // Iterate over all requirements and look for conflicting accesses

  // For a given requirement, checks for conflicts and adds any
  // conflicting operations as dependencies
  auto add_conflicts_as_requirements = [&](dag_node_ptr req_node){
    if(req_node->get_operation()->is_requirement()){
      auto* req = cast<requirement>(req_node->get_operation());

      if(req->is_memory_requirement()){
        auto* mem_req = cast<memory_requirement>(req);

        if(mem_req->is_image_requirement())
          assert(false && "dag_builder: Image requirements are unimplemented");
        else {
          auto* buff_req = cast<buffer_memory_requirement>(req);

          data_user_tracker &user_tracker =
              buff_req->get_data_region()->get_users();

          user_tracker.for_each_user([&](data_user &user) {
            auto user_ptr = user.user.lock();
            if(user_ptr && is_conflicting_access(mem_req, user))
            {
              // No reason to take a dependency into account that is alreay completed
              if(!user_ptr->is_known_complete())
                req_node->add_requirement(user_ptr);
            }
          });
        }
      }
    }
  };

  auto operation_node = std::make_shared<dag_node>(
      hints, requirements.get(), std::move(op), _rt);
  
  bool is_req = operation_node->get_operation()->is_requirement();

  // Do not change order between add_conflicts_as_requirements()
  // and add_to_data_users() to prevent this node ending up as a
  // requirement to itself or other cyclic requirements!
  if(is_req)
    // If we are an explicit requirement, consider conflicts not only
    // with our requirements, but with the node itself
    add_conflicts_as_requirements(operation_node);
  
  for (auto weak_node : operation_node->get_requirements()) {
    if(auto node = weak_node.lock())
      add_conflicts_as_requirements(node);
  }