Hacktoberfest 2026: những issue maintainer đã đánh dấu cho tháng Mười, đang mở và phù hợp người mới. Xem issue Hacktoberfest

Track outstanding GPU work per allocation for host-accessible arrays

Đã đóng
  • Có gì không ổn?
#652 0 bình luận 0 reaction 0 người được giao Xem trên GitHub

Maintainer thường phản hồi trong vòng 1 ngày

@maleadt đang làm issue này rồi.

Từ ngày 13/10/2026.

  • #686 của @maleadt — đang mở

Đánh giá

Độ khó
5/5
Thời gian dự kiến
Hơn một tuần
Mức phù hợp với người mới
45/100
Loại issue
Tính năng
Độ rõ ràng
Khá rõ ràng
Mức độ hoạt động
Sôi nổi
Công nghệ
julia
Lĩnh vực
hpc

Hướng nghiên cứu

Start by tracing oneArray's DataRef and the unsafe_convert methods for ZePtr and Ptr, along with scalar indexing and host↔shared unsafe_copyto! paths. Compare the ownership and synchronization behavior described for CUDA.jl, then add tests for broadcast followed by scalar indexing and for a kernel launched from another task and read from the parent. Done means host access synchronizes only dirty buffers on their owning stream, including cross-task and user-queue work.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.

Mô tả

Arrays backed by SharedBuffer or HostBuffer can be accessed directly from the CPU, so every host access has to wait for outstanding GPU work on the buffer first. #649 fixes the most visible symptom (sum/maximum returning 0) by unconditionally synchronizing the current task's stream in scalar getindex/setindex!. That is correct for the single-task case, but has a few problems:

  • Cost. Every element access now does a device() and global_stream task-local lookup plus a zeCommandListHostSynchronize (and a queue sync if oneMKL was used). A CPU loop over a shared array, which is the main reason to make these arrays host-indexable, turns into a driver call per element.
  • Other tasks. Only the calling task's stream is synchronized. Work on the buffer submitted from another task, or to a user-created queue, is not waited for.
  • Other host accesses. Taking a CPU pointer through unsafe_convert(Ptr{T}, x) (unsafe_wrap(Array, a), passing a to a CPU ccall, ...) doesn't synchronize at all. The host↔shared unsafe_copyto! methods each synchronize explicitly to compensate.

How CUDA.jl does it

CUDA.jl wraps every allocation in a Managed object (CUDACore/src/memory.jl) that records the stream that last used it and whether that use has been synchronized:

  • Converting the array to a device pointer (convert(CuPtr, ::Managed), i.e. every kernel launch or copy) calls take_ownership!, which records the current stream and sets dirty = true. Switching to a different stream first syncs the previous owner.
  • Converting to a host pointer (convert(Ptr, ::Managed)) calls maybe_synchronize, which syncs the owning stream only if the allocation is dirty, and then clears the flag.

Scalar indexing goes through pointer(x, I; type=HostMemory), so it needs no explicit synchronization: the first access after GPU work syncs, later ones cost a lock and a Bool check. Because the owning stream is synchronized rather than the caller's, cross-task use works as well. (There's also a captured flag that forces synchronization for memory used during stream capture, which has no oneAPI equivalent yet.)

What oneAPI.jl would need

oneArray.data is a DataRef around the raw oneL0 buffer, so there's no place to keep this state. Roughly:

  1. Wrap buffers in a small mutable object holding the owning oneStream and a dirty flag (plus a lock), at least for host-accessible buffers.
  2. Set ownership and dirty in unsafe_convert(::Type{ZePtr{T}}, ::oneArray), synchronizing the previous owner when the stream changes.
  3. Call maybe_synchronize in unsafe_convert(::Type{Ptr{T}}, ::oneArray), and drop the explicit synchronization from scalar indexing and from the host↔shared unsafe_copyto! methods.

Tests should cover broadcast followed by scalar indexing (not just reductions) and a kernel launched from another task and read from the parent.

Possibly related: #458.

Ngôn ngữ chính
Julia
Star
217
Fork
37
Merge trung bình
1 ngày 7 giờ
Pull request đã merge (30 ngày)
45

Chuẩn bị môi trường

Dự án này không cung cấp dev container, Dockerfile hay hướng dẫn đóng góp, nên bạn cần tự thiết lập môi trường: hãy bắt đầu từ README và xem hướng dẫn đóng góp lần đầu của chúng tôi để biết các bước chung.

Bắt đầu từ đâu

  1. Đọc hết issue, rồi đọc hướng dẫn đóng góp của dự án.
  2. Bình luận trên issue rằng bạn sẽ nhận — tránh hai người làm cùng một việc.
  3. Fork repository và làm thay đổi trên một nhánh.
  4. Mở pull request có tham chiếu số hiệu của issue.

Issue khác của JuliaGPU/oneAPI.jl

Tất cả issue của JuliaGPU/oneAPI.jl

Issue tương tự

Thêm issue về Julia

Nhận issue mới trong hộp thư của bạn

Bản tóm tắt ngắn những issue GitHub phù hợp với người mới.