Rename attributes

Make attributes less specific to tracing.

Author: wks

docs/userguide/src/tutorial/code/mygc_semispace/global.rs

@@ -31,11 +31,13 @@ use mmtk_macros::PlanTraceObject;
 #[derive(PlanTraceObject)]
 pub struct MyGC<VM: VMBinding> {
     pub hi: AtomicBool,
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+#[copy_semantics(CopySemantics::DefaultCopy)]
     pub copyspace0: CopySpace<VM>,
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+#[copy_semantics(CopySemantics::DefaultCopy)]
     pub copyspace1: CopySpace<VM>,
-    #[fallback_trace]
+    #[parent]
     pub common: CommonPlan<VM>,
 }
 // ANCHOR_END: plan_def

docs/userguide/src/tutorial/mygc/ss/collection.md

@@ -182,9 +182,10 @@ it can use `PlanProcessEdges`.
 You can manually provide an implementation of `PlanTraceObject` for `MyGC`. But you can also use the derive macro MMTK provides,
 and the macro will generate an implementation of `PlanTraceObject`:
 * add `#[derive(PlanTraceObject)]` for `MyGC` (import the macro properly: `use mmtk_macros::PlanTraceObject`)
-* add `#[trace(CopySemantics::Default)]` to both copy space fields, `copyspace0` and `copyspace1`. This tells the macro to generate
+* add `#[space]
+#[copy_semantics(CopySemantics::Default)]` to both copy space fields, `copyspace0` and `copyspace1`. This tells the macro to generate
   trace code for both spaces, and for any copying in the spaces, use `CopySemantics::DefaultCopy` that we have configured early.
-* add `#[fallback_trace]` to `common`. This tells the macro that if an object is not found in any space with `#[trace]` in ths plan,
+* add `#[parent]` to `common`. This tells the macro that if an object is not found in any space with `#[space]` in ths plan,
   try find the space for the object in the 'parent' plan. In our case, we fall back to the `CommonPlan`, as the object may be
   in large object space or immortal space in the common plan. `CommonPlan` also implements `PlanTraceObject`, so it knows how to
   find a space for the object and trace it in the same way.
@@ -244,4 +245,4 @@ If the benchmarks pass - good job! You have built a functional copying
 collector!
 
 If you get particularly stuck, the code for the completed `MyGC` plan
-is available [here](https://github.com/mmtk/mmtk-core/tree/master/docs/tutorial/code/mygc_semispace).
+is available [here](https://github.com/mmtk/mmtk-core/tree/master/docs/tutorial/code/mygc_semispace).

macros/src/lib.rs

@@ -28,7 +28,7 @@ const DEBUG_MACRO_OUTPUT: bool = false;
 /// * add `#[post_scan]` to any space field that has some policy-specific post_scan_object(). For objects in those spaces,
 ///   `post_scan_object()` in the policy will be called after `VM::VMScanning::scan_object()`.
 #[proc_macro_error]
-#[proc_macro_derive(PlanTraceObject, attributes(trace, post_scan, fallback_trace))]
+#[proc_macro_derive(PlanTraceObject, attributes(space, parent, copy_semantics, post_scan))]
 pub fn derive_plan_trace_object(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let ident = input.ident;
@@ -41,19 +41,16 @@ pub fn derive_plan_trace_object(input: TokenStream) -> TokenStream {
         abort_call_site!("`#[derive(PlanTraceObject)]` only supports structs with named fields.");
     };
 
-    let spaces = util::get_fields_with_attribute(fields, "trace");
+    let spaces = util::get_fields_with_attribute(fields, "space");
     let post_scan_spaces = util::get_fields_with_attribute(fields, "post_scan");
-    let fallback = util::get_unique_field_with_attribute(fields, "fallback_trace");
+    let parent = util::get_unique_field_with_attribute(fields, "parent");
 
     let trace_object_function =
-        plan_trace_object_impl::generate_trace_object(&spaces, &fallback, &ty_generics);
-    let post_scan_object_function = plan_trace_object_impl::generate_post_scan_object(
-        &post_scan_spaces,
-        &fallback,
-        &ty_generics,
-    );
+        plan_trace_object_impl::generate_trace_object(&spaces, &parent, &ty_generics);
+    let post_scan_object_function =
+        plan_trace_object_impl::generate_post_scan_object(&post_scan_spaces, &parent, &ty_generics);
     let may_move_objects_function =
-        plan_trace_object_impl::generate_may_move_objects(&spaces, &fallback, &ty_generics);
+        plan_trace_object_impl::generate_may_move_objects(&spaces, &parent, &ty_generics);
 
     let output = quote! {
         impl #impl_generics crate::plan::PlanTraceObject #ty_generics for #ident #ty_generics #where_clause {

macros/src/plan_trace_object_impl.rs

@@ -16,24 +16,26 @@ pub(crate) fn generate_trace_object<'a>(
         let f_ty = &f.ty;
 
         // Figure out copy
-        let trace_attr = util::get_field_attribute(f, "trace").unwrap();
-        let copy = match &trace_attr.meta {
-            syn::Meta::Path(_) => {
-                // #[trace]
-                quote!{ None }
-            },
-            syn::Meta::List(list) => {
-                // #[trace(CopySemantics::BlahBlah)]
-                let copy_semantics = list.parse_args::<Expr>().unwrap_or_else(|_| {
-                    abort_call_site!("In `#[trace(copy_semantics)]`, copy_semantics must be an expression.");
-                });
-
-                quote!{ Some(#copy_semantics) }
-            },
-            syn::Meta::NameValue(_) => {
-                // #[trace = BlahBlah]
-                abort_call_site!("The #[trace] macro does not support name-value form.");
-            },
+        let maybe_copy_semantics_attr = util::get_field_attribute(f, "copy_semantics");
+        let copy = match maybe_copy_semantics_attr {
+            None => quote!{ None },
+            Some(attr) => match &attr.meta {
+                syn::Meta::Path(_) => {
+                    // #[copy_semantics]
+                    abort_call_site!("The `#[copy_semantics(expr)]` macro needs an argument.");
+                },
+                syn::Meta::List(list) => {
+                    // #[copy_semantics(BlahBlah)]
+                    let copy_semantics = list.parse_args::<Expr>().unwrap_or_else(|_| {
+                        abort_call_site!("In `#[copy_semantics(expr)]`, expr must be an expression.");
+                    });
+                    quote!{ Some(#copy_semantics) }
+                },
+                syn::Meta::NameValue(_) => {
+                    // #[copy_semantics = BlahBlah]
+                    abort_call_site!("The #[copy_semantics] macro does not support the name-value form.");
+                },
+            }
         };
 
         quote! {

src/plan/generational/copying/global.rs

@@ -31,12 +31,14 @@ use mmtk_macros::PlanTraceObject;
 
 #[derive(PlanTraceObject)]
 pub struct GenCopy<VM: VMBinding> {
-    #[fallback_trace]
+    #[parent]
     pub gen: CommonGenPlan<VM>,
     pub hi: AtomicBool,
-    #[trace(CopySemantics::Mature)]
+    #[space]
+    #[copy_semantics(CopySemantics::Mature)]
     pub copyspace0: CopySpace<VM>,
-    #[trace(CopySemantics::Mature)]
+    #[space]
+    #[copy_semantics(CopySemantics::Mature)]
     pub copyspace1: CopySpace<VM>,
 }
 

src/plan/generational/global.rs

@@ -24,10 +24,11 @@ use mmtk_macros::PlanTraceObject;
 #[derive(PlanTraceObject)]
 pub struct CommonGenPlan<VM: VMBinding> {
     /// The nursery space.
-    #[trace(CopySemantics::PromoteToMature)]
+    #[space]
+    #[copy_semantics(CopySemantics::PromoteToMature)]
     pub nursery: CopySpace<VM>,
     /// The common plan.
-    #[fallback_trace]
+    #[parent]
     pub common: CommonPlan<VM>,
     /// Is this GC full heap?
     pub gc_full_heap: AtomicBool,

src/plan/generational/immix/global.rs

@@ -38,11 +38,12 @@ use mmtk_macros::PlanTraceObject;
 #[derive(PlanTraceObject)]
 pub struct GenImmix<VM: VMBinding> {
     /// Generational plan, which includes a nursery space and operations related with nursery.
-    #[fallback_trace]
+    #[parent]
     pub gen: CommonGenPlan<VM>,
     /// An immix space as the mature space.
     #[post_scan]
-    #[trace(CopySemantics::Mature)]
+    #[space]
+    #[copy_semantics(CopySemantics::Mature)]
     pub immix_space: ImmixSpace<VM>,
     /// Whether the last GC was a defrag GC for the immix space.
     pub last_gc_was_defrag: AtomicBool,

src/plan/global.rs

@@ -431,13 +431,13 @@ pub struct BasePlan<VM: VMBinding> {
 
     // Spaces in base plan
     #[cfg(feature = "code_space")]
-    #[trace]
+    #[space]
     pub code_space: ImmortalSpace<VM>,
     #[cfg(feature = "code_space")]
-    #[trace]
+    #[space]
     pub code_lo_space: ImmortalSpace<VM>,
     #[cfg(feature = "ro_space")]
-    #[trace]
+    #[space]
     pub ro_space: ImmortalSpace<VM>,
 
     /// A VM space is a space allocated and populated by the VM.  Currently it is used by JikesRVM
@@ -453,7 +453,7 @@ pub struct BasePlan<VM: VMBinding> {
     /// -   The `is_in_mmtk_spaces` currently returns `true` if the given object reference is in
     ///     the VM space.
     #[cfg(feature = "vm_space")]
-    #[trace]
+    #[space]
     pub vm_space: VMSpace<VM>,
 }
 
@@ -898,14 +898,14 @@ CommonPlan is for representing state and features used by _many_ plans, but that
 */
 #[derive(PlanTraceObject)]
 pub struct CommonPlan<VM: VMBinding> {
-    #[trace]
+    #[space]
     pub immortal: ImmortalSpace<VM>,
-    #[trace]
+    #[space]
     pub los: LargeObjectSpace<VM>,
     // TODO: We should use a marksweep space for nonmoving.
-    #[trace]
+    #[space]
     pub nonmoving: ImmortalSpace<VM>,
-    #[fallback_trace]
+    #[parent]
     pub base: BasePlan<VM>,
 }
 

src/plan/immix/global.rs

@@ -29,9 +29,10 @@ use mmtk_macros::PlanTraceObject;
 #[derive(PlanTraceObject)]
 pub struct Immix<VM: VMBinding> {
     #[post_scan]
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+    #[copy_semantics(CopySemantics::DefaultCopy)]
     pub immix_space: ImmixSpace<VM>,
-    #[fallback_trace]
+    #[parent]
     pub common: CommonPlan<VM>,
     last_gc_was_defrag: AtomicBool,
 }

src/plan/markcompact/global.rs

@@ -29,9 +29,10 @@ use mmtk_macros::PlanTraceObject;
 
 #[derive(PlanTraceObject)]
 pub struct MarkCompact<VM: VMBinding> {
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+    #[copy_semantics(CopySemantics::DefaultCopy)]
     pub mc_space: MarkCompactSpace<VM>,
-    #[fallback_trace]
+    #[parent]
     pub common: CommonPlan<VM>,
 }
 

src/plan/marksweep/global.rs

@@ -30,9 +30,9 @@ use crate::policy::marksweepspace::native_ms::MAX_OBJECT_SIZE;
 
 #[derive(PlanTraceObject)]
 pub struct MarkSweep<VM: VMBinding> {
-    #[fallback_trace]
+    #[parent]
     common: CommonPlan<VM>,
-    #[trace]
+    #[space]
     ms: MarkSweepSpace<VM>,
 }
 

src/plan/pageprotect/global.rs

@@ -22,7 +22,7 @@ use mmtk_macros::PlanTraceObject;
 
 #[derive(PlanTraceObject)]
 pub struct PageProtect<VM: VMBinding> {
-    #[trace]
+    #[space]
     pub space: LargeObjectSpace<VM>,
     pub common: CommonPlan<VM>,
 }

src/plan/semispace/global.rs

@@ -25,11 +25,13 @@ use enum_map::EnumMap;
 #[derive(PlanTraceObject)]
 pub struct SemiSpace<VM: VMBinding> {
     pub hi: AtomicBool,
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+    #[copy_semantics(CopySemantics::DefaultCopy)]
     pub copyspace0: CopySpace<VM>,
-    #[trace(CopySemantics::DefaultCopy)]
+    #[space]
+    #[copy_semantics(CopySemantics::DefaultCopy)]
     pub copyspace1: CopySpace<VM>,
-    #[fallback_trace]
+    #[parent]
     pub common: CommonPlan<VM>,
 }
 

src/plan/sticky/immix/global.rs

@@ -28,7 +28,7 @@ use super::gc_work::StickyImmixNurseryGCWorkContext;
 
 #[derive(PlanTraceObject)]
 pub struct StickyImmix<VM: VMBinding> {
-    #[fallback_trace]
+    #[parent]
     immix: immix::Immix<VM>,
     gc_full_heap: AtomicBool,
     next_gc_full_heap: AtomicBool,