Struct Topology

pub struct Topology { /* private fields */ }

Implementations

impl Topology

pub fn new() -> Topology

Creates a new Topology.

If no further customization is needed on init, this method represents the main entry point. A topology is returned which contains the logical representation of the physical hardware.

Examples

use hwloc::Topology;

let topology = Topology::new();

Note that the topology implements the Drop trait, so when it goes out of scope no further cleanup is necessary.

Examples found in repository

examples/walk_tree.rs (line 7)

fn main() {
    let topo = Topology::new();

    println!("*** Printing overall tree");
    print_children(&topo, topo.object_at_root(), 0);
}

examples/walk_linear.rs (line 8)

fn main() {
    let topo = Topology::new();

    for i in 0..topo.depth() {
        println!("*** Objects at level {}", i);

        for (idx, object) in topo.objects_at_depth(i).iter().enumerate() {
            println!("{}: {}", idx, object);
        }
    }
}

examples/number_of_packages.rs (line 7)

fn main() {
    let topo = Topology::new();

    let package_depth = topo.depth_for_type(&ObjectType::Package);
    match package_depth {
        Ok(depth) => println!("*** {} package(s)", topo.size_at_depth(depth)),
        Err(TypeDepthError::TypeDepthUnknown) => println!("*** The number of packages is unknown"),
        Err(e) => println!("Unknown Error: {:?}", e),
    }
}

examples/processor_cache.rs (line 8)

fn main() {
    let topo = Topology::new();

    let pu = topo.objects_with_type(&ObjectType::PU).unwrap()[0];

    let mut parent = pu.parent();
    let mut levels = 0;
    let mut size = 0;

    while let Some(p) = parent {
        if p.object_type() == ObjectType::Cache {
            levels += 1;
            // This should actually be size(), but there is a (compiler) bug? with the c-ffi unions
            size += p.cache_attributes().unwrap().size;
        }
        parent = p.parent();
    }

    println!("*** Logical processor 0 has {} caches totalling {} KB",
             levels,
             size / 1024);
}

examples/support.rs (line 7)

fn main() {
    let topo = Topology::new();

    // Check if Process Binding for CPUs is supported
    println!("CPU Binding (current process) supported: {}",
             topo.support().cpu().set_current_process());
    println!("CPU Binding (any process) supported: {}",
             topo.support().cpu().set_process());

    // Check if Thread Binding for CPUs is supported
    println!("CPU Binding (current thread) supported: {}",
             topo.support().cpu().set_current_thread());
    println!("CPU Binding (any thread) supported: {}",
             topo.support().cpu().set_thread());

    // Check if Memory Binding is supported
    println!("Memory Binding supported: {}",
             topo.support().memory().set_current_process());

    // Debug Print all the Support Flags
    println!("All Flags:\n{:?}", topo.support());
}

examples/bind_to_last_core.rs (line 20)

fn main() {
    let mut topo = Topology::new();

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    //  Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    // Print the current cpu binding before explicit setting
    println!("Cpu Binding before explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location before explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));

    // Try to bind all threads of the current (possibly multithreaded) process.
    match topo.set_cpubind(cpuset, CPUBIND_PROCESS) {
        Ok(_) => println!("Correctly bound to last core"),
        Err(e) => println!("Failed to bind: {:?}", e),
    }

    // Print the current cpu binding after explicit setting
    println!("Cpu Binding after explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location after explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));
}

Additional examples can be found in:

• examples/bind_process.rs
• examples/bind_threads.rs

pub fn with_flags(flags: Vec<TopologyFlag>) -> Topology

Creates a new Topology with custom flags.

This method works like new, but allows to provide a vector of flags which customize the topology discovery process.

Examples

use hwloc::{Topology, TopologyFlag};

let topology = Topology::with_flags(vec![TopologyFlag::IoDevices]);

Note that the topology implements the Drop trait, so when it goes out of scope no further cleanup is necessary.

pub fn support(&self) -> &TopologySupport

Examples found in repository

examples/support.rs (line 11)

fn main() {
    let topo = Topology::new();

    // Check if Process Binding for CPUs is supported
    println!("CPU Binding (current process) supported: {}",
             topo.support().cpu().set_current_process());
    println!("CPU Binding (any process) supported: {}",
             topo.support().cpu().set_process());

    // Check if Thread Binding for CPUs is supported
    println!("CPU Binding (current thread) supported: {}",
             topo.support().cpu().set_current_thread());
    println!("CPU Binding (any thread) supported: {}",
             topo.support().cpu().set_thread());

    // Check if Memory Binding is supported
    println!("Memory Binding supported: {}",
             topo.support().memory().set_current_process());

    // Debug Print all the Support Flags
    println!("All Flags:\n{:?}", topo.support());
}

pub fn flags(&self) -> Vec<TopologyFlag>

Returns the flags currently set for this topology.

Note that the flags are only used during initialization, so this method can just be used for debugging purposes.

Examples

use hwloc::{Topology,TopologyFlag};

let default_topology = Topology::new();
assert_eq!(0, default_topology.flags().len());

let topology_with_flags = Topology::with_flags(vec![TopologyFlag::IoDevices]);
assert_eq!(vec![TopologyFlag::IoDevices], topology_with_flags.flags());

pub fn depth(&self) -> u32

Returns the full depth of the topology.

In practice, the full depth of the topology equals the depth of the ObjectType::PU plus one.

The full topology depth is useful to know if one needs to manually traverse the complete topology.

Examples

use hwloc::Topology;

let topology = Topology::new();
assert!(topology.depth() > 0);

Examples found in repository

examples/walk_linear.rs (line 10)

fn main() {
    let topo = Topology::new();

    for i in 0..topo.depth() {
        println!("*** Objects at level {}", i);

        for (idx, object) in topo.objects_at_depth(i).iter().enumerate() {
            println!("{}: {}", idx, object);
        }
    }
}

pub fn depth_for_type( &self, object_type: &ObjectType, ) -> Result<u32, TypeDepthError>

Returns the depth for the given ObjectType.

Examples

use hwloc::{Topology,ObjectType};

let topology = Topology::new();

let machine_depth = topology.depth_for_type(&ObjectType::Machine).unwrap();
let pu_depth = topology.depth_for_type(&ObjectType::PU).unwrap();
assert!(machine_depth < pu_depth);

Failures

If hwloc can’t find the depth for the given ObjectType, this method will return an error from the TypeDepthError enum. See this one for more info on each specific error.

Note that for ObjectType::Bridge, ObjectType::PCIDevice and ObjectType::OSDevice, always an error will be returned which signals their virtual depth.

Examples found in repository

examples/number_of_packages.rs (line 9)

fn main() {
    let topo = Topology::new();

    let package_depth = topo.depth_for_type(&ObjectType::Package);
    match package_depth {
        Ok(depth) => println!("*** {} package(s)", topo.size_at_depth(depth)),
        Err(TypeDepthError::TypeDepthUnknown) => println!("*** The number of packages is unknown"),
        Err(e) => println!("Unknown Error: {:?}", e),
    }
}

pub fn depth_or_below_for_type( &self, object_type: &ObjectType, ) -> Result<u32, TypeDepthError>

Examples found in repository

examples/bind_process.rs (line 51)

fn last_core(topo: &mut Topology) -> &TopologyObject {
    let core_depth = topo.depth_or_below_for_type(&ObjectType::Core).unwrap();
    let all_cores = topo.objects_at_depth(core_depth);
    all_cores.last().unwrap()
}

examples/bind_to_last_core.rs (line 49)

fn last_core(topo: &mut Topology) -> &TopologyObject {
    let core_depth = topo.depth_or_below_for_type(&ObjectType::Core).unwrap();
    let all_cores = topo.objects_at_depth(core_depth);
    all_cores.last().unwrap()
}

pub fn depth_or_above_for_type( &self, object_type: &ObjectType, ) -> Result<u32, TypeDepthError>

pub fn type_at_depth(&self, depth: u32) -> ObjectType

Returns the corresponding ObjectType for the given depth.

Examples

use hwloc::{Topology,ObjectType};

let topology = Topology::new();

// Load depth for PU to assert against
let pu_depth = topology.depth_for_type(&ObjectType::PU).unwrap();
// Retrieve the type for the given depth
assert_eq!(ObjectType::PU, topology.type_at_depth(pu_depth));

Panics

This method will panic if the given depth is larger than the full depth minus one. It can’t be negative since its an unsigned integer, but be careful with the depth provided in general.

pub fn size_at_depth(&self, depth: u32) -> u32

Returns the number of objects at the given depth.

Examples

use hwloc::Topology;

let topology = Topology::new();

let topo_depth = topology.depth();
assert!(topology.size_at_depth(topo_depth - 1) > 0);

Panics

This method will panic if the given depth is larger than the full depth minus one. It can’t be negative since its an unsigned integer, but be careful with the depth provided in general.

Examples found in repository

examples/number_of_packages.rs (line 11)

fn main() {
    let topo = Topology::new();

    let package_depth = topo.depth_for_type(&ObjectType::Package);
    match package_depth {
        Ok(depth) => println!("*** {} package(s)", topo.size_at_depth(depth)),
        Err(TypeDepthError::TypeDepthUnknown) => println!("*** The number of packages is unknown"),
        Err(e) => println!("Unknown Error: {:?}", e),
    }
}

pub fn object_at_root(&self) -> &TopologyObject

Returns the TopologyObject at the root of the topology.

Examples

use hwloc::{Topology,TopologyObject};

let topology = Topology::new();

assert_eq!(topology.type_at_root(), topology.object_at_root().object_type());

Examples found in repository

examples/walk_tree.rs (line 10)

fn main() {
    let topo = Topology::new();

    println!("*** Printing overall tree");
    print_children(&topo, topo.object_at_root(), 0);
}

pub fn type_at_root(&self) -> ObjectType

Returns the ObjectType at the root of the topology.

This method is a convenient shorthand for type_at_depth(0).

Examples

use hwloc::{Topology,ObjectType};

let topology = Topology::new();

let root_type = topology.type_at_root();
let depth_type = topology.type_at_depth(0);
assert_eq!(root_type, depth_type);

pub fn objects_with_type( &self, object_type: &ObjectType, ) -> Result<Vec<&TopologyObject>, TypeDepthError>

Returns all TopologyObjects with the given ObjectType.

Examples found in repository

examples/processor_cache.rs (line 10)

fn main() {
    let topo = Topology::new();

    let pu = topo.objects_with_type(&ObjectType::PU).unwrap()[0];

    let mut parent = pu.parent();
    let mut levels = 0;
    let mut size = 0;

    while let Some(p) = parent {
        if p.object_type() == ObjectType::Cache {
            levels += 1;
            // This should actually be size(), but there is a (compiler) bug? with the c-ffi unions
            size += p.cache_attributes().unwrap().size;
        }
        parent = p.parent();
    }

    println!("*** Logical processor 0 has {} caches totalling {} KB",
             levels,
             size / 1024);
}

examples/bind_threads.rs (line 30)

fn main() {
    let topo = Arc::new(Mutex::new(Topology::new()));

    // Grab the number of cores in a block so that the lock is removed once
    // the end of the block is reached.
    let num_cores = {
        let topo_rc = topo.clone();
        let topo_locked = topo_rc.lock().unwrap();
        (*topo_locked)
            .objects_with_type(&ObjectType::Core)
            .unwrap()
            .len()
    };
    println!("Found {} cores.", num_cores);

    // Spawn one thread for each and pass the topology down into scope.
    let handles: Vec<_> = (0..num_cores)
        .map(|i| {
            let child_topo = topo.clone();
            thread::spawn(move || {
                // Get the current thread id and lock the topology to use.
                let tid = get_thread_id();
                let mut locked_topo = child_topo.lock().unwrap();

                // Thread binding before explicit set.
                let before = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);

                // load the cpuset for the given core index.
                let mut bind_to = cpuset_for_core(&*locked_topo, i);

                // Get only one logical processor (in case the core is SMT/hyper-threaded).
                bind_to.singlify();

                // Set the binding.
                locked_topo
                    .set_cpubind_for_thread(tid, bind_to, CPUBIND_THREAD)
                    .unwrap();

                // Thread binding after explicit set.
                let after = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);
                println!("Thread {}: Before {:?}, After {:?}", i, before, after);
            })
        })
        .collect();

    // Wait for all threads to complete before ending the program.
    for h in handles {
        h.join().unwrap();
    }
}

/// Load the `CpuSet` for the given core index.
fn cpuset_for_core(topology: &Topology, idx: usize) -> CpuSet {
    let cores = (*topology).objects_with_type(&ObjectType::Core).unwrap();
    match cores.get(idx) {
        Some(val) => val.cpuset().unwrap(),
        None => panic!("No Core found with id {}", idx),
    }
}

pub fn objects_at_depth(&self, depth: u32) -> Vec<&TopologyObject>

Returns all TopologyObjects at the given depth.

Examples found in repository

examples/bind_process.rs (line 52)

fn last_core(topo: &mut Topology) -> &TopologyObject {
    let core_depth = topo.depth_or_below_for_type(&ObjectType::Core).unwrap();
    let all_cores = topo.objects_at_depth(core_depth);
    all_cores.last().unwrap()
}

examples/bind_to_last_core.rs (line 50)

fn last_core(topo: &mut Topology) -> &TopologyObject {
    let core_depth = topo.depth_or_below_for_type(&ObjectType::Core).unwrap();
    let all_cores = topo.objects_at_depth(core_depth);
    all_cores.last().unwrap()
}

examples/walk_linear.rs (line 13)

fn main() {
    let topo = Topology::new();

    for i in 0..topo.depth() {
        println!("*** Objects at level {}", i);

        for (idx, object) in topo.objects_at_depth(i).iter().enumerate() {
            println!("{}: {}", idx, object);
        }
    }
}

pub fn set_cpubind( &mut self, set: CpuSet, flags: CpuBindFlags, ) -> Result<(), CpuBindError>

Binds the current process or thread on CPUs given in the CpuSet.

Examples found in repository

examples/bind_to_last_core.rs (line 35)

fn main() {
    let mut topo = Topology::new();

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    //  Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    // Print the current cpu binding before explicit setting
    println!("Cpu Binding before explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location before explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));

    // Try to bind all threads of the current (possibly multithreaded) process.
    match topo.set_cpubind(cpuset, CPUBIND_PROCESS) {
        Ok(_) => println!("Correctly bound to last core"),
        Err(e) => println!("Failed to bind: {:?}", e),
    }

    // Print the current cpu binding after explicit setting
    println!("Cpu Binding after explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location after explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));
}

pub fn get_cpubind(&self, flags: CpuBindFlags) -> Option<CpuSet>

Get current process or thread binding.

Examples found in repository

examples/bind_to_last_core.rs (line 30)

fn main() {
    let mut topo = Topology::new();

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    //  Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    // Print the current cpu binding before explicit setting
    println!("Cpu Binding before explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location before explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));

    // Try to bind all threads of the current (possibly multithreaded) process.
    match topo.set_cpubind(cpuset, CPUBIND_PROCESS) {
        Ok(_) => println!("Correctly bound to last core"),
        Err(e) => println!("Failed to bind: {:?}", e),
    }

    // Print the current cpu binding after explicit setting
    println!("Cpu Binding after explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location after explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));
}

pub fn set_cpubind_for_process( &mut self, pid: pid_t, set: CpuSet, flags: CpuBindFlags, ) -> Result<(), CpuBindError>

Binds a process (identified by its pid) on CPUs identified by the given CpuSet.

Examples found in repository

examples/bind_process.rs (line 36)

fn main() {
    let mut topo = Topology::new();

    // load the current pid through libc
    let pid = get_pid();

    println!("Binding Process with PID {:?}", pid);

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    // Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    println!("Before Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }

    // Bind to one core.
    topo.set_cpubind_for_process(pid, cpuset, CPUBIND_PROCESS)
        .unwrap();

    println!("After Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }
}

pub fn get_cpubind_for_process( &self, pid: pid_t, flags: CpuBindFlags, ) -> Option<CpuSet>

Get the current physical binding of a process, identified by its pid.

Examples found in repository

examples/bind_process.rs (line 27)

fn main() {
    let mut topo = Topology::new();

    // load the current pid through libc
    let pid = get_pid();

    println!("Binding Process with PID {:?}", pid);

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    // Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    println!("Before Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }

    // Bind to one core.
    topo.set_cpubind_for_process(pid, cpuset, CPUBIND_PROCESS)
        .unwrap();

    println!("After Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }
}

pub fn set_cpubind_for_thread( &mut self, tid: pthread_t, set: CpuSet, flags: CpuBindFlags, ) -> Result<(), CpuBindError>

Bind a thread (by its tid) on CPUs given in through the CpuSet.

Examples found in repository

examples/bind_threads.rs (line 56)

fn main() {
    let topo = Arc::new(Mutex::new(Topology::new()));

    // Grab the number of cores in a block so that the lock is removed once
    // the end of the block is reached.
    let num_cores = {
        let topo_rc = topo.clone();
        let topo_locked = topo_rc.lock().unwrap();
        (*topo_locked)
            .objects_with_type(&ObjectType::Core)
            .unwrap()
            .len()
    };
    println!("Found {} cores.", num_cores);

    // Spawn one thread for each and pass the topology down into scope.
    let handles: Vec<_> = (0..num_cores)
        .map(|i| {
            let child_topo = topo.clone();
            thread::spawn(move || {
                // Get the current thread id and lock the topology to use.
                let tid = get_thread_id();
                let mut locked_topo = child_topo.lock().unwrap();

                // Thread binding before explicit set.
                let before = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);

                // load the cpuset for the given core index.
                let mut bind_to = cpuset_for_core(&*locked_topo, i);

                // Get only one logical processor (in case the core is SMT/hyper-threaded).
                bind_to.singlify();

                // Set the binding.
                locked_topo
                    .set_cpubind_for_thread(tid, bind_to, CPUBIND_THREAD)
                    .unwrap();

                // Thread binding after explicit set.
                let after = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);
                println!("Thread {}: Before {:?}, After {:?}", i, before, after);
            })
        })
        .collect();

    // Wait for all threads to complete before ending the program.
    for h in handles {
        h.join().unwrap();
    }
}

pub fn get_cpubind_for_thread( &self, tid: pthread_t, flags: CpuBindFlags, ) -> Option<CpuSet>

Get the current physical binding of thread tid.

Examples found in repository

examples/bind_threads.rs (line 46)

fn main() {
    let topo = Arc::new(Mutex::new(Topology::new()));

    // Grab the number of cores in a block so that the lock is removed once
    // the end of the block is reached.
    let num_cores = {
        let topo_rc = topo.clone();
        let topo_locked = topo_rc.lock().unwrap();
        (*topo_locked)
            .objects_with_type(&ObjectType::Core)
            .unwrap()
            .len()
    };
    println!("Found {} cores.", num_cores);

    // Spawn one thread for each and pass the topology down into scope.
    let handles: Vec<_> = (0..num_cores)
        .map(|i| {
            let child_topo = topo.clone();
            thread::spawn(move || {
                // Get the current thread id and lock the topology to use.
                let tid = get_thread_id();
                let mut locked_topo = child_topo.lock().unwrap();

                // Thread binding before explicit set.
                let before = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);

                // load the cpuset for the given core index.
                let mut bind_to = cpuset_for_core(&*locked_topo, i);

                // Get only one logical processor (in case the core is SMT/hyper-threaded).
                bind_to.singlify();

                // Set the binding.
                locked_topo
                    .set_cpubind_for_thread(tid, bind_to, CPUBIND_THREAD)
                    .unwrap();

                // Thread binding after explicit set.
                let after = locked_topo.get_cpubind_for_thread(tid, CPUBIND_THREAD);
                println!("Thread {}: Before {:?}, After {:?}", i, before, after);
            })
        })
        .collect();

    // Wait for all threads to complete before ending the program.
    for h in handles {
        h.join().unwrap();
    }
}

pub fn get_cpu_location(&self, flags: CpuBindFlags) -> Option<CpuSet>

Get the last physical CPU where the current process or thread ran.

The operating system may move some tasks from one processor to another at any time according to their binding, so this function may return something that is already outdated.

Flags can include either CPUBIND_PROCESS or CPUBIND_THREAD to specify whether the query should be for the whole process (union of all CPUs on which all threads are running), or only the current thread. If the process is single-threaded, flags can be set to zero to let hwloc use whichever method is available on the underlying OS.

Examples found in repository

examples/bind_to_last_core.rs (line 32)

fn main() {
    let mut topo = Topology::new();

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    //  Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    // Print the current cpu binding before explicit setting
    println!("Cpu Binding before explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location before explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));

    // Try to bind all threads of the current (possibly multithreaded) process.
    match topo.set_cpubind(cpuset, CPUBIND_PROCESS) {
        Ok(_) => println!("Correctly bound to last core"),
        Err(e) => println!("Failed to bind: {:?}", e),
    }

    // Print the current cpu binding after explicit setting
    println!("Cpu Binding after explicit bind: {:?}",
             topo.get_cpubind(CPUBIND_PROCESS));
    println!("Cpu Location after explicit bind: {:?}",
             topo.get_cpu_location(CPUBIND_PROCESS));
}

pub fn get_cpu_location_for_process( &self, pid: pid_t, flags: CpuBindFlags, ) -> Option<CpuSet>

Get the last physical CPU where a process ran.

The operating system may move some tasks from one processor to another at any time according to their binding, so this function may return something that is already outdated.

Examples found in repository

examples/bind_process.rs (line 31)

fn main() {
    let mut topo = Topology::new();

    // load the current pid through libc
    let pid = get_pid();

    println!("Binding Process with PID {:?}", pid);

    // Grab last core and exctract its CpuSet
    let mut cpuset = last_core(&mut topo).cpuset().unwrap();

    // Get only one logical processor (in case the core is SMT/hyper-threaded).
    cpuset.singlify();

    println!("Before Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }

    // Bind to one core.
    topo.set_cpubind_for_process(pid, cpuset, CPUBIND_PROCESS)
        .unwrap();

    println!("After Bind: {:?}",
             topo.get_cpubind_for_process(pid, CPUBIND_PROCESS)
                 .unwrap());

    // Last CPU Location for this PID (not implemented on all systems)
    if let Some(l) = topo.get_cpu_location_for_process(pid, CPUBIND_PROCESS) {
        println!("Last Known CPU Location: {:?}", l);
    }
}

Trait Implementations

impl Default for Topology

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Topology

fn drop(&mut self)

Executes the destructor for this type.

impl Send for Topology

impl Sync for Topology