wip

Author: ZuseZ4

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -235,6 +235,18 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 codegen_offload(self, tcx, instance, args);
                 return Ok(());
             }
+            sym::preload => {
+                if tcx.sess.opts.unstable_opts.offload.is_empty() {
+                    let _ = tcx.dcx().emit_almost_fatal(OffloadWithoutEnable);
+                }
+
+                if tcx.sess.lto() != rustc_session::config::Lto::Fat {
+                    let _ = tcx.dcx().emit_almost_fatal(OffloadWithoutFatLTO);
+                }
+
+                codegen_offload_preload(self, tcx, instance, args);
+                return Ok(());
+            }
             sym::is_val_statically_known => {
                 if let OperandValue::Immediate(imm) = args[0].val {
                     self.call_intrinsic(
@@ -1847,6 +1859,43 @@ fn codegen_autodiff<'ll, 'tcx>(
     );
 }
 
+// For each PreLoad *call*, we now use some of our previous declared globals to move data to the gpu.
+// For now, we only handle the data transfer part of it. Consecutive calls become a no-op on the
+// LLVM side.
+//
+// Current steps:
+// 0. Alloca some variables for the following steps
+// 1. set insert point before PreLoad call.
+// 2. generate all the GEPS and stores, to be used in 3)
+// 3. generate __tgt_target_data_begin calls to move data to the GPU
+//
+// unchanged: keep kernel call. Later move the kernel to the GPU
+//
+// 4. set insert point after kernel call.
+// 5. generate all the GEPS and stores, to be used in 6)
+// 6. generate __tgt_target_data_end calls to move data from the GPU
+fn codegen_offload_preload<'ll, 'tcx>(
+    bx: &mut Builder<'_, 'll, 'tcx>,
+    tcx: TyCtxt<'tcx>,
+    instance: ty::Instance<'tcx>,
+    args: &[OperandRef<'tcx, &'ll Value>],
+) {
+    let cx = bx.cx;
+    //let fn_args = instance.args;
+
+    register_offload(cx);
+    let a = OffloadMetadata::from_ty(tcx, args[0]);
+
+    let offload_globals_ref = cx.offload_globals.borrow();
+    let offload_globals = match offload_globals_ref.as_ref() {
+        Some(globals) => globals,
+        None => {
+            // Offload is not initialized, cannot continue
+            return;
+        }
+    };
+}
+
 // Generates the LLVM code to offload a Rust function to a target device (e.g., GPU).
 // For each kernel call, it generates the necessary globals (including metadata such as
 // size and pass mode), manages memory mapping to and from the device, handles all

compiler/rustc_hir/src/lang_items.rs

@@ -325,6 +325,12 @@ language_item_table! {
     DropGlue,                sym::drop_glue,           drop_glue_fn,               Target::Fn,             GenericRequirement::Exact(1);
     AllocLayout,             sym::alloc_layout,        alloc_layout,               Target::Struct,         GenericRequirement::None;
 
+    // Compiler-generated mapper functions for gpu offloading
+    PreloadStruct,        sym::preload_type,        preload_type,        Target::Struct, GenericRequirement::None;
+    PreloadMutStruct,     sym::preload_mut_type,    preload_mut_type,    Target::Struct, GenericRequirement::None;
+    PreloadFn,            sym::preload,             preload_fn,          Target::Fn,     GenericRequirement::None;
+    PreloadMutFn,         sym::preload_mut,         preload_mut_fn,      Target::Fn,     GenericRequirement::None;
+
     /// For all binary crates without `#![no_main]`, Rust will generate a "main" function.
     /// The exact name and signature are target-dependent. The "main" function will invoke
     /// this lang item, passing it the `argc` and `argv` (or null, if those don't exist

compiler/rustc_span/src/symbol.rs

@@ -1557,6 +1557,10 @@ symbols! {
         prefetch_write_instruction,
         prefix_nops,
         preg,
+        preload,
+        preload_mut,
+        preload_type,
+        preload_mut_type,
         prelude,
         prelude_import,
         preserves_flags,

library/core/src/lib.rs

@@ -235,6 +235,12 @@ pub mod autodiff {
     #[unstable(feature = "autodiff", issue = "124509")]
     pub use crate::macros::builtin::{autodiff_forward, autodiff_reverse};
 }
+#[unstable(feature = "offload", issue = "124509")]
+pub mod offload;
+//pub mod offload {
+//    #[unstable(feature = "offload", issue = "124509")]
+//    pub use crate::offload::{Preload, PreloadMut};
+//}
 
 #[unstable(feature = "contracts", issue = "128044")]
 pub mod contracts;

library/core/src/offload.rs

@@ -0,0 +1,14 @@
+use crate::marker::PhantomData;
+use crate::ptr;
+
+#[lang = "preload_type"]
+pub struct Preload<'a, T: ?Sized> {
+    cpu_ptr: *const T,
+    _marker: PhantomData<&'a T>,
+}
+
+#[lang = "preload_mut_type"]
+pub struct PreloadMut<'a, T: ?Sized> {
+    cpu_ptr: *mut T,
+    _marker: PhantomData<&'a mut T>,
+}