mbarrier 0.1.3

Cross-platform memory barrier implementations for Rust, inspired by Linux kernel
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

name: CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  CARGO_TERM_COLOR: always

jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        target:
          # x86 targets
          - x86_64-unknown-none
          - i686-unknown-linux-gnu
          # ARM targets
          - aarch64-unknown-none
          - armv7-unknown-linux-gnueabihf
          - arm-unknown-linux-gnueabihf
          # RISC-V targets
          - riscv64gc-unknown-none-elf
          - riscv32imac-unknown-none-elf

    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        target: ${{ matrix.target }}
        override: true
        components: rustfmt, clippy

    - name: Build
      run: cargo build --target ${{ matrix.target }} --verbose

    - name: Build with SMP feature
      run: cargo build --target ${{ matrix.target }} --features smp --verbose

    - name: Build examples
      run: cargo build --examples --verbose

    - name: Run tests
      run: cargo test --verbose

  test-qemu:
    name: Test with QEMU
    runs-on: ubuntu-latest
    strategy:
      matrix:
        include:
          # RISC-V 64-bit (use Linux target for testing)
          - target: riscv64gc-unknown-linux-gnu
            arch: riscv64
            qemu_arch: riscv64
            qemu_cpu: rv64
          # ARM 64-bit (use Linux target for testing)
          - target: aarch64-unknown-linux-gnu
            arch: aarch64
            qemu_arch: aarch64
            qemu_cpu: cortex-a72
          # ARM 32-bit (use Linux target for testing)
          - target: armv7-unknown-linux-gnueabihf
            arch: armv7
            qemu_arch: arm
            qemu_cpu: cortex-a15

    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        target: ${{ matrix.target }}
        override: true
        components: rustfmt, clippy

    - name: Install QEMU and cross-compilation tools
      run: |
        sudo apt-get update
        sudo apt-get install -y qemu-user qemu-user-static
        case "${{ matrix.arch }}" in
          "riscv64")
            sudo apt-get install -y gcc-riscv64-linux-gnu libc6-dev-riscv64-cross
            ;;
          "aarch64")
            sudo apt-get install -y gcc-aarch64-linux-gnu libc6-dev-arm64-cross
            ;;
          "armv7")
            sudo apt-get install -y gcc-arm-linux-gnueabihf libc6-dev-armhf-cross
            ;;
        esac

    - name: Configure cross-compilation
      run: |
        mkdir -p ~/.cargo
        cat >> ~/.cargo/config.toml << EOF
        [target.riscv64gc-unknown-linux-gnu]
        linker = "riscv64-linux-gnu-gcc"
        rustflags = ["-C", "target-feature=+crt-static"]

        [target.aarch64-unknown-linux-gnu]
        linker = "aarch64-linux-gnu-gcc"
        rustflags = ["-C", "target-feature=+crt-static"]

        [target.armv7-unknown-linux-gnueabihf]
        linker = "arm-linux-gnueabihf-gcc"
        rustflags = ["-C", "target-feature=+crt-static"]
        EOF

    - name: Build for target
      run: cargo build --target ${{ matrix.target }} --verbose

    - name: Build with SMP feature
      run: cargo build --target ${{ matrix.target }} --features smp --verbose

    - name: Run tests with QEMU
      run: |
        # Build test binary
        cargo test --target ${{ matrix.target }} --no-run --verbose
        
        # Find the test binary
        TEST_BINARY=$(find target/${{ matrix.target }}/debug/deps -name 'mbarrier-*' -type f -executable | head -1)
        
        if [ -z "$TEST_BINARY" ]; then
          echo "Test binary not found"
          exit 1
        fi
        
        echo "Running test binary: $TEST_BINARY"
        
        # Run tests with QEMU
        case "${{ matrix.qemu_arch }}" in
          "riscv64")
            qemu-riscv64-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
          "aarch64")
            qemu-aarch64-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
          "arm")
            qemu-arm-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
        esac

    - name: Run tests with SMP features using QEMU
      run: |
        # Clean previous builds
        cargo clean --target ${{ matrix.target }}
        
        # Build test binary with SMP features
        cargo test --target ${{ matrix.target }} --features smp --no-run --verbose
        
        # Find the test binary
        TEST_BINARY=$(find target/${{ matrix.target }}/debug/deps -name 'mbarrier-*' -type f -executable | head -1)
        
        if [ -z "$TEST_BINARY" ]; then
          echo "SMP test binary not found"
          exit 1
        fi
        
        echo "Running SMP test binary: $TEST_BINARY"
        
        # Run SMP tests with QEMU
        case "${{ matrix.qemu_arch }}" in
          "riscv64")
            qemu-riscv64-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
          "aarch64")
            qemu-aarch64-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
          "arm")
            qemu-arm-static -cpu ${{ matrix.qemu_cpu }} "$TEST_BINARY"
            ;;
        esac