fe-dev-dl/Ornith-1.0-9B-Hardware-Expert-fp16
Text Generation • 6B • Updated • 17 • 1
instruction stringlengths 195 298 | thought stringlengths 277 39.8k | response stringlengths 201 18k |
|---|---|---|
TARGET ENTITY: no_atomic.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [no_atomic.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety v... | // This file is @generated by no_atomic.sh.
// It is not intended for manual editing.
const NO_ATOMIC: &[&str] = &[
"armv4t-none-eabi",
"armv5te-none-eabi",
"bpfeb-unknown-none",
"bpfel-unknown-none",
"mipsel-sony-psx",
"msp430-none-elf",
"thumbv4t-none-eabi",
"thumbv5te-none-eabi",
];
|
TARGET ENTITY: build-common.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [build-common.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safet... | // The target triplets have the form of 'arch-vendor-system'.
//
// When building for Linux (e.g. the 'system' part is
// 'linux-something'), replace the vendor with 'unknown'
// so that mapping to rust standard targets happens correctly.
fn convert_custom_linux_target(target: String) -> String {
let mut parts: Vec... |
TARGET ENTITY: build.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [build.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via s... | // The rustc-cfg listed below are considered public API, but it is *unstable*
// and outside of the normal semver guarantees:
//
// - `crossbeam_no_atomic`
// Assume the target does *not* support any atomic operations.
// This is usually detected automatically by the build script, but you may
// need to ... |
TARGET ENTITY: parker.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [parker.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via ... | use std::{thread::sleep, time::Duration};
use crossbeam_utils::{
sync::{Parker, UnparkReason},
thread,
};
#[test]
fn park_timeout_unpark_before() {
let p = Parker::new();
for _ in 0..10 {
p.unparker().unpark();
assert_eq!(
p.park_timeout(Duration::from_millis(u32::MAX as u6... |
TARGET ENTITY: wait_group.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [wait_group.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety ... | use std::{sync::mpsc, thread, time::Duration};
use crossbeam_utils::sync::WaitGroup;
const THREADS: usize = 10;
#[test]
fn wait() {
let wg = WaitGroup::new();
let (tx, rx) = mpsc::channel();
for _ in 0..THREADS {
let wg = wg.clone();
let tx = tx.clone();
thread::spawn(move || {
... |
TARGET ENTITY: atomic_cell.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [atomic_cell.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety... | use std::{
mem,
sync::atomic::{AtomicUsize, Ordering::SeqCst},
};
use crossbeam_utils::atomic::AtomicCell;
// Always use fallback for now on environments that do not support inline assembly.
fn always_use_fallback() -> bool {
atomic_maybe_uninit::cfg_has_atomic_cas! {
cfg!(any(
miri,
... |
TARGET ENTITY: cache_padded.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [cache_padded.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safet... | use std::{cell::Cell, mem};
use crossbeam_utils::CachePadded;
#[test]
fn default() {
let x: CachePadded<u64> = Default::default();
assert_eq!(*x, 0);
}
#[test]
fn store_u64() {
let x: CachePadded<u64> = CachePadded::new(17);
assert_eq!(*x, 17);
}
#[test]
fn store_pair() {
let x: CachePadded<(u64... |
TARGET ENTITY: thread.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [thread.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via ... | use std::{
any::Any,
sync::atomic::{AtomicUsize, Ordering},
thread::sleep,
time::Duration,
};
use crossbeam_utils::thread;
const THREADS: usize = 10;
const SMALL_STACK_SIZE: usize = 20;
#[test]
fn join() {
let counter = AtomicUsize::new(0);
thread::scope(|scope| {
let handle = scope.s... |
TARGET ENTITY: sharded_lock.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [sharded_lock.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safet... | use std::{
sync::{
Arc, TryLockError,
atomic::{AtomicUsize, Ordering},
mpsc::channel,
},
thread,
};
use crossbeam_utils::sync::ShardedLock;
#[derive(Eq, PartialEq, Debug)]
struct NonCopy(i32);
#[test]
fn smoke() {
let l = ShardedLock::new(());
drop(l.read().unwrap());
... |
TARGET ENTITY: alloc_helper.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [alloc_helper.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safet... | use core::{alloc::Layout, ptr::NonNull};
// Based on unstable alloc::alloc::Global.
//
// Note: unlike alloc::alloc::Global that returns NonNull<[u8]>,
// this returns NonNull<u8>.
pub(crate) struct Global;
#[allow(clippy::unused_self)]
impl Global {
#[inline]
#[cfg_attr(miri, track_caller)] // even without pa... |
TARGET ENTITY: lib.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [lib.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via str... | //! Miscellaneous tools for concurrent programming.
//!
//! ## Atomics
//!
//! * [`AtomicCell`], a thread-safe mutable memory location.
//! * [`AtomicConsume`], for reading from primitive atomic types with "consume" ordering.
//!
//! ## Thread synchronization
//!
//! * [`Parker`], a thread parking primitive.
//! * [`Sh... |
TARGET ENTITY: backoff.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [backoff.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via... | use core::{cell::Cell, fmt};
use crate::primitive::hint;
const SPIN_LIMIT: u32 = 6;
const YIELD_LIMIT: u32 = 10;
/// Performs exponential backoff in spin loops.
///
/// Backing off in spin loops reduces contention and improves overall performance.
///
/// This primitive can execute *YIELD* and *PAUSE* instructions, ... |
TARGET ENTITY: cache_padded.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [cache_padded.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safet... | use core::{
fmt,
ops::{Deref, DerefMut},
};
/// Pads and aligns a value to the length of a cache line.
///
/// In concurrent programming, sometimes it is desirable to make sure commonly accessed pieces of
/// data are not placed into the same cache line. Updating an atomic value invalidates the whole
/// cache... |
TARGET ENTITY: seq_lock_wide.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [seq_lock_wide.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safe... | use core::{
mem,
sync::atomic::{self, AtomicUsize, Ordering},
};
use crate::Backoff;
/// A simple stamped lock.
///
/// The state is represented as two `AtomicUsize`: `state_hi` for high bits and `state_lo` for low
/// bits.
pub(crate) struct SeqLock {
/// The high bits of the current state of the lock.
... |
TARGET ENTITY: seq_lock.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [seq_lock.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety vi... | use core::{
mem,
sync::atomic::{self, AtomicUsize, Ordering},
};
use crate::Backoff;
/// A simple stamped lock.
pub(crate) struct SeqLock {
/// The current state of the lock.
///
/// All bits except the least significant one hold the current stamp. When locked, the state
/// equals 1 and doesn... |
TARGET ENTITY: consume.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [consume.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via... | #[cfg(not(crossbeam_no_atomic))]
use core::sync::atomic::Ordering;
/// Trait which allows reading from primitive atomic types with "consume" ordering.
pub trait AtomicConsume {
/// Type returned by `load_consume`.
type Val;
/// Loads a value from the atomic using a "consume" memory ordering.
///
/... |
TARGET ENTITY: mod.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [mod.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via str... | //! Atomic types.
//!
//! * [`AtomicCell`], a thread-safe mutable memory location.
//! * [`AtomicConsume`], for reading from primitive atomic types with "consume" ordering.
#[cfg(target_has_atomic = "ptr")]
#[cfg(not(crossbeam_loom))]
// Use "wide" sequence lock if the pointer width <= 32 for preventing its counter ag... |
TARGET ENTITY: parker.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [parker.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via ... | use core::{fmt, marker::PhantomData, time::Duration};
use std::time::Instant;
use crate::primitive::sync::{
Arc, Condvar, Mutex,
atomic::{AtomicUsize, Ordering::SeqCst},
};
/// A thread parking primitive.
///
/// Conceptually, each `Parker` has an associated token which is initially not present:
///
/// * The... |
TARGET ENTITY: wait_group.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [wait_group.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety ... | use core::{fmt, mem::ManuallyDrop};
use crate::primitive::sync::{
Arc, Condvar, Mutex,
atomic::{AtomicUsize, Ordering},
};
/// Enables threads to synchronize the beginning or end of some computation.
///
/// # Wait groups vs barriers
///
/// `WaitGroup` is very similar to [`Barrier`], but there are a few diff... |
TARGET ENTITY: mod.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [mod.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via str... | //! Thread synchronization primitives.
//!
//! * [`Parker`], a thread parking primitive.
//! * [`ShardedLock`], a sharded reader-writer lock with fast concurrent reads.
//! * [`WaitGroup`], for synchronizing the beginning or end of some computation.
#[cfg(not(crossbeam_loom))]
mod once_lock;
mod parker;
#[cfg(not(cros... |
TARGET ENTITY: once_lock.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [once_lock.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety v... | // Based on unstable std::sync::OnceLock.
//
// Source: https://github.com/rust-lang/rust/blob/8e9c93df464b7ada3fc7a1c8ccddd9dcb24ee0a0/library/std/src/sync/once_lock.rs
use core::{cell::UnsafeCell, mem::MaybeUninit};
use std::sync::Once;
pub(crate) struct OnceLock<T> {
once: Once,
value: UnsafeCell<MaybeUnin... |
TARGET ENTITY: atomic_cell.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [atomic_cell.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety... | #![feature(test)]
extern crate test;
use std::sync::Barrier;
use crossbeam_utils::{atomic::AtomicCell, thread};
#[bench]
fn load_u8(b: &mut test::Bencher) {
let a = AtomicCell::new(0u8);
let mut sum = 0;
b.iter(|| sum += a.load());
test::black_box(sum);
}
#[bench]
fn store_u8(b: &mut test::Bencher)... |
TARGET ENTITY: seg_queue.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [seg_queue.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety v... | use std::sync::atomic::{AtomicUsize, Ordering};
use crossbeam_queue::SegQueue;
use crossbeam_utils::thread::scope;
#[test]
fn smoke() {
let q = SegQueue::new();
q.push(7);
assert_eq!(q.pop(), Some(7));
q.push(8);
assert_eq!(q.pop(), Some(8));
assert!(q.pop().is_none());
}
#[test]
fn len_empt... |
TARGET ENTITY: array_queue.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [array_queue.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety... | use std::sync::atomic::{AtomicUsize, Ordering};
use crossbeam_queue::ArrayQueue;
use crossbeam_utils::thread::scope;
#[test]
fn smoke() {
let q = ArrayQueue::new(1);
q.push(7).unwrap();
assert_eq!(q.pop(), Some(7));
q.push(8).unwrap();
assert_eq!(q.pop(), Some(8));
assert!(q.pop().is_none())... |
TARGET ENTITY: lib.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [lib.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via str... | //! Concurrent queues.
//!
//! This crate provides concurrent queues that can be shared among threads:
//!
//! * [`ArrayQueue`], a bounded MPMC queue that allocates a fixed-capacity buffer on construction.
//! * [`SegQueue`], an unbounded MPMC queue that allocates small buffers, segments, on demand.
#![no_std]
#![doc(... |
TARGET ENTITY: subcrates.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [subcrates.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety v... | //! Makes sure subcrates are properly re-exported.
use crossbeam::select;
#[test]
fn channel() {
let (s, r) = crossbeam::channel::bounded(1);
select! {
send(s, 0) -> res => res.unwrap(),
recv(r) -> res => assert!(res.is_ok()),
}
}
#[test]
fn deque() {
let w = crossbeam::deque::Worker... |
TARGET ENTITY: build.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [build.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via s... | // The rustc-cfg emitted by the build script are *not* public API.
use std::env;
fn main() {
println!("cargo:rerun-if-changed=build.rs");
println!("cargo:rustc-check-cfg=cfg(crossbeam_sanitize_thread)");
// `cfg(sanitize = "..")` is not stabilized.
let sanitize = env::var("CARGO_CFG_SANITIZE").unwrap... |
TARGET ENTITY: loom.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [loom.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via st... | // Put in module instead of using #![cfg(..)] to work around rustc/cargo bug around -Z crate-attr.
#[cfg(crossbeam_loom)]
mod tests {
use std::{mem::ManuallyDrop, ptr};
use crossbeam_epoch as epoch;
use epoch::{Atomic, Owned, *};
use loom::{
sync::{
Arc,
atomic::Ordering... |
TARGET ENTITY: default.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [default.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via... | //! The default garbage collector.
//!
//! For each thread, a participant is lazily initialized on its first use, when the current thread
//! is registered in the default collector. If initialized, the thread's participant will get
//! destructed on thread exit, which in turn unregisters the thread.
#[cfg(not(crossbe... |
TARGET ENTITY: epoch.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [epoch.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via s... | //! The global epoch
//!
//! The last bit in this number is unused and is always zero. Every so often the global epoch is
//! incremented, i.e. we say it "advances". A pinned participant may advance the global epoch only
//! if all currently pinned participants have been pinned in the current epoch.
//!
//! If an objec... |
TARGET ENTITY: collector.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [collector.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety v... | /// Epoch-based garbage collector.
///
/// # Examples
///
/// ```
/// use crossbeam_epoch::Collector;
///
/// let collector = Collector::new();
///
/// let handle = collector.register();
/// drop(collector); // `handle` still works after dropping `collector`
///
/// handle.pin().flush();
/// ```
use core::fmt;
use cra... |
TARGET ENTITY: lib.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [lib.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via str... | //! Epoch-based memory reclamation.
//!
//! An interesting problem concurrent collections deal with comes from the remove operation.
//! Suppose that a thread removes an element from a lock-free map, while another thread is reading
//! that same element at the same time. The first thread must wait until the second thre... |
TARGET ENTITY: deferred.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [deferred.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety vi... | use alloc::boxed::Box;
use core::{
fmt,
marker::PhantomData,
mem::{self, MaybeUninit},
ptr,
};
/// Number of words a piece of `Data` can hold.
///
/// Three words should be enough for the majority of cases. For example, you can fit inside it the
/// function pointer together with a fat pointer represen... |
TARGET ENTITY: queue.rs
LANGUAGE BASE: Rust
COMPUTATION METRICS: Enforce zero-leak hardware boundaries.
EXECUTION MANDATE: Synthesize exact low-level assembly-optimized structural runtime primitives. | CRITICAL COMPILER REASONING FOR MODULE [queue.rs]:
- Scanning data layouts to prevent L1/L2 cache-line bouncing and enforce rigid cache line memory padding alignment.
- Eliminating implicit virtual method table lookups, stripping object abstractions, and locking structural memory paths.
- Validating thread safety via s... | //! Michael-Scott lock-free queue.
//!
//! Usable with any number of producers and consumers.
//!
//! Michael and Scott. Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue
//! Algorithms. PODC 1996. <http://dl.acm.org/citation.cfm?id=248106>
//!
//! Simon Doherty, Lindsay Groves, Victor Luchangco... |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 77
Models trained or fine-tuned on fe-dev-dl/grand-master-hardware-expert