pub fn new_partial_allocation(size: usize, flags: PhysallocFlags, strategy: Option<PartialAllocStrategy>, mut min: usize) -> Result<Self> {
        debug_assert!(!(flags.contains(PhysallocFlags::PARTIAL_ALLOC) && strategy.is_none()));

        let address = unsafe { crate::physalloc3(size, flags.bits() | strategy.map(|s| s as usize).unwrap_or(0), &mut min)? };
        Ok(Self {
            address,
            size: min,
        })
    }
/// "Partially" allocate physical memory, in the sense that the allocation may be smaller than
/// expected, but still with a minimum limit. This is particularly useful when the physical
/// memory space is fragmented, and a device supports scatter-gather I/O. In that case, the
/// driver can optimistically request e.g. 1 alloc of 1 MiB, with the minimum of 512 KiB. If
/// that first allocation only returns half the size, the driver can do another allocation
/// and then let the device use both buffers.
"Partially" allocate physical memory, in the sense that the allocation may be smaller than
expected, but still with a minimum limit. This is particularly useful when the physical
memory space is fragmented, and a device supports scatter-gather I/O. In that case, the
driver can optimistically request e.g. 1 alloc of 1 MiB, with the minimum of 512 KiB. If
that first allocation only returns half the size, the driver can do another allocation
and then let the device use both buffers.
" Partially " allocate physical memory in the sense that the allocation may be smaller than expected but still with a minimum limit . This is particularly useful when the physical memory space is fragmented and a device supports scatter - gather I / O . In that case the driver can optimistically request e . g . 1 alloc of 1 MiB with the minimum of 512 KiB . If that first allocation only returns half the size the driver can do another allocation and then let the device use both buffers .
pub fn new_partial_allocation(size: usize, flags: PhysallocFlags, strategy: Option<PartialAllocStrategy>, mut min: usize) -> Result<Self> {
        debug_assert!(!(flags.contains(PhysallocFlags::PARTIAL_ALLOC) && strategy.is_none()));
        let address = unsafe { crate::physalloc3(size, flags.bits() | strategy.map(|s| s as usize).unwrap_or(0), &mut min)? };
        Ok(Self {
            address,
            size: min,
        })
    }
pub fn new_partial_allocation ( size : usize , flags : PhysallocFlags , strategy : Option < PartialAllocStrategy > , mut min : usize ) -> Result < Self > { debug_assert ! ( ( flags contains ( PhysallocFlags PARTIAL_ALLOC ) strategy is_none ( ) ) ) ; let address = unsafe { crate :: physalloc3 ( size , flags . bits ( ) | strategy . map ( | s | s as usize ) . unwrap_or ( 0 ) , & mut min ) ? } ; Ok ( Self { address , size : min , } ) }
"Partially" allocate physical memory, in the sense that the allocation may be smaller than
expected, but still with a minimum limit.
" Partially " allocate physical memory in the sense that the allocation may be smaller than expected but still with a minimum limit .
size
usize
flags
PhysallocFlags
strategy
Option<PartialAllocStrategy>
min
usize
size
usize
flags
PhysallocFlags
strategy
Option<PartialAllocStrategy>
min
usize