Início / coding / Perguntas / 79081751
Accepted
A. K.
Asked: 2024-10-13 03:32:58 +0800 CST

Erro: o atributo `align` só pode ser aplicado a uma struct, enum ou union

  • 772

Como posso alinhar membro de struct a um limite específico. Uma motivação seria desabilitar o compartilhamento falso.

Considere este exemplo:

use std::sync::atomic::AtomicBool;
pub struct Foo {
    id: String,
    read: AtomicBool,
    #[repr(align(64))]
    write: AtomicBool
}

error[E0517]: attribute should be applied to a struct, enum, function, associated function, or union
 --> src/lib.rs:5:12
  |
5 |     #[repr(align(64))]
  |            ^^^^^^^^^
6 |     write: AtomicBool
  |     ----------------- not a struct, enum, function, associated function, or union

For more information about this error, try `rustc --explain E0517`.
rust

2 respostas

  1. Best Answer

    Crie um tipo de wrapper:

    use std::sync::atomic::AtomicBool;

#[repr(align(64))]
struct CacheAligned<T>(T);

#[repr(C)]
pub struct Foo {
    id: String,
    read: AtomicBool,
    write: CacheAligned<AtomicBool>,
}

    Você também deve usar #[repr(C)]se estiver interessado em um layout específico; caso contrário, o layout não será especificado.

    • 3

  2. Se não for muito inconveniente, você pode incorporar o bool atômico em sua própria struct com alinhamento adequado.
    Se você quiser algum tipo de controle sobre a ordem dos membros na Foostruct, repr(C)ajuda.
    No exemplo abaixo, brincar com repr(align(64))mostra as situações de compartilhamento falso (ou não).

    use std::sync::atomic::AtomicBool;

#[repr(align(64))] // comment this to test
#[derive(Default)]
struct AlignedAtomicBool(AtomicBool);

#[repr(C)] // preserve order of members
#[derive(Default)]
pub struct Foo {
    read: AlignedAtomicBool,
    id: String,
    write: AlignedAtomicBool,
}

fn test_false_sharing(f: &Foo) {
    let addr1 = &f.read.0 as *const _ as usize;
    let addr2 = &f.write.0 as *const _ as usize;
    if addr1 / 64 == addr2 / 64 {
        println!("false sharing");
    }
}

fn main() {
    let foo = Foo::default();
    test_false_sharing(&foo);
    for n in 1..100 {
        let v = Vec::from_iter((0..n).map(|_| Foo::default()));
        for f in v.iter() {
            test_false_sharing(f);
        }
    }
}
    • 1

relate perguntas