Get moving: move semantics, type systems, and resource management

Jun 23, 2024

Introduction

C++11 introduced move semantics, a feature that allows the efficient transfer of resources from one object to another. This feature is essential for optimizing performance and reducing memory usage in C++ programs. Rust, on the other hand, has a unique ownership model that enforces strict rules on borrowing and lifetimes, making memory safety a core feature of the language. This model simplifies move semantics as the compiler enforces ownership rules, reducing the need for explicit move operations.

The semantics part might be daunting. But there is nothing fancy about move semantics: a constructor that takes an rvalue reference is a move constructor.

An easy move

Rust’s ownership model enforces strict rules on borrowing and lifetimes, making memory safety a core feature of the language. This model simplifies move semantics as the compiler enforces ownership rules, reducing the need for explicit move operations.

#![allow(dead_code)]

use std::time::Instant;
use std::hint::black_box;

#[derive(Clone)]
struct DynamicArray {
    data: Vec<i32>,
}

impl DynamicArray {
    // Constructor
    fn new(size: usize) -> DynamicArray {
        DynamicArray {
            data: vec![0; size],
        }
    }
}

fn main() {
    let array_size = 1_000_000;
    let num_iterations = 100;

    // Benchmark copying
    {
        let start = Instant::now();

        for _ in 0..num_iterations {
            let arr1 = DynamicArray::new(array_size);
            let arr2 = arr1.clone(); // Clone (similar to copy constructor)
            black_box(&arr2); // Prevent optimization
        }

        let duration = start.elapsed();
        println!("Rust Copying duration: {:?}", duration);
    }

    // Benchmark moving
    {
        let start = Instant::now();

        for _ in 0..num_iterations {
            let arr1 = DynamicArray::new(array_size);
            let arr2 = arr1; // Move semantics
            black_box(&arr2); // Prevent optimization
        }

        let duration = start.elapsed();
        println!("Rust Moving duration: {:?}", duration);
    }
}

# Mac M2 Max
Rust Copying duration: 59.434625ms
Rust Moving duration: 16.7275ms

In some systems, the performance difference between copying and moving can be significant.

# EC2 m5zn
Rust Copying duration: 314.324077ms
Rust Moving duration: 15.254347ms

A less easy but faster move?

C++ move semantics can seem verbose compared to Rust due to several reasons rooted in language design philosophies, memory management, and type safety features. Learning move semantics in C++ requires a solid understanding of advanced C++ features such as rvalue references, perfect forwarding, and the details of resource management.

#include <iostream>
#include <chrono>
#include <algorithm>

// Class with copy semantics
class DynamicArrayCopy {
    int *data;
    size_t size;

public:
    // Constructor
    DynamicArrayCopy(size_t s) : size(s), data(new int[s]) {}

    // Destructor
    ~DynamicArrayCopy() { delete[] data; }

    // Copy Constructor
    DynamicArrayCopy(const DynamicArrayCopy &other) :
            size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + other.size, data);
    }

    // Copy Assignment Operator
    DynamicArrayCopy &operator=(const DynamicArrayCopy &other) {
        if (this != &other) {
            // Release existing resources
            delete[] data;

            // Allocate new resources and copy the data
            size = other.size;
            data = new int[other.size];
            std::copy(other.data, other.data + other.size, data);
        }
        return *this;
    }

};

// Class with move semantics
class DynamicArrayMove {
    int *data;
    size_t size;

public:
    // Constructor
    DynamicArrayMove(size_t s) : size(s), data(new int[s]) {}

    // Destructor
    ~DynamicArrayMove() { delete[] data; }

    // Move Constructor
    DynamicArrayMove(DynamicArrayMove &&other) noexcept: data(nullptr), size(0) {
        // Transfer ownership
        data = other.data;
        size = other.size;

        // Nullify the source object
        other.data = nullptr;
        other.size = 0;
    }

    // Move Assignment Operator
    DynamicArrayMove &operator=(DynamicArrayMove &&other) noexcept {
        if (this != &other) {
            // Release existing resources
            delete[] data;

            // Transfer ownership
            data = other.data;
            size = other.size;

            // Nullify the source object
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

int main() {
    const size_t arraySize = 1000000;
    const size_t numIterations = 100;

    // Benchmark copying
    {
        auto start = std::chrono::high_resolution_clock::now();

        for (size_t i = 0; i < numIterations; ++i) {
            DynamicArrayCopy arr1(arraySize);
            DynamicArrayCopy arr2 = arr1;  // Copy constructor
        }

        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;
        std::cout << "Copying duration: " << duration.count() * 1000 << "ms" << std::endl;
    }

    // Benchmark moving
    {
        auto start = std::chrono::high_resolution_clock::now();

        for (size_t i = 0; i < numIterations; ++i) {
            DynamicArrayMove arr1(arraySize);
            DynamicArrayMove arr2 = std::move(arr1);  // Move constructor
        }

        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;
        std::cout << "Moving duration: " << duration.count() * 1000 << "ms" << std::endl;
    }

    return 0;
}

You essentially have to write a move constructor and a move assignment operator to implement move semantics in C++. The move constructor transfers ownership of the data pointer from the source object to the destination object and nullifies the source object’s data pointer. The move assignment operator does the same but also releases the destination object’s existing resources before transferring ownership. “Remember to use std::move in the second constructor! Inside the constructor, obj is an lvalue, so writing member(obj) would copy it, not move it.” —Jonathan Müller

foo(const T& obj)
: member(obj) {}

foo(T&& obj)
: member(std::move(obj)) {}

Interestingly, C++ move semantics can be faster than Rust move semantics in some systems. Jimmy Hartzell has a nice post on C++ move semantics that provides a detailed comparison of C++ move semantics with Rust.

# Mac M2 Max
Copying duration: 42.2133ms
Moving duration: 0.778584ms

# EC2 m5zn
Copying duration: 311.815ms
Moving duration: 0.00673ms

A modern move?

#include <iostream>
#include <chrono>
#include <algorithm>
#include <vector>

// Class with copy semantics
class DynamicArrayCopy {
    std::vector<int> data;

public:
    // Constructor
    DynamicArrayCopy(size_t s) : data(s) {}

    // Copy Constructor
    DynamicArrayCopy(const DynamicArrayCopy &other) = default;

    // Copy Assignment Operator
    DynamicArrayCopy &operator=(const DynamicArrayCopy &other) = default;

    // Destructor
    ~DynamicArrayCopy() = default;
};

// Class with move semantics
class DynamicArrayMove {
    std::vector<int> data;

public:
    // Constructor
    DynamicArrayMove(size_t s) : data(s) {}

    // Move Constructor
    DynamicArrayMove(DynamicArrayMove &&other) noexcept = default;

    // Move Assignment Operator
    DynamicArrayMove &operator=(DynamicArrayMove &&other) noexcept = default;

    // Destructor
    ~DynamicArrayMove() = default;
};

int main() {
    const size_t arraySize = 1000000;
    const size_t numIterations = 100;

    // Benchmark copying
    {
        auto start = std::chrono::high_resolution_clock::now();

        for (size_t i = 0; i < numIterations; ++i) {
            DynamicArrayCopy arr1(arraySize);
            DynamicArrayCopy arr2 = arr1;  // Copy constructor
        }

        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;
        std::cout << "Copying duration: " << duration.count() * 1000 << "ms" << std::endl;
    }

    // Benchmark moving
    {
        auto start = std::chrono::high_resolution_clock::now();

        for (size_t i = 0; i < numIterations; ++i) {
            DynamicArrayMove arr1(arraySize);
            DynamicArrayMove arr2 = std::move(arr1);  // Move constructor
        }

        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> duration = end - start;
        std::cout << "Moving duration: " << duration.count() * 1000 << "ms" << std::endl;
    }

    return 0;
}

# Mac M2 Max
Copying duration: 1561.38ms
Moving duration: 1058.36ms

# EC2 m5zn
Copying duration: 533.044ms
Moving duration: 164.411ms

In C++, special member functions (default constructor, destructor, copy constructor, copy assignment operator, move constructor, and move assignment operator) are automatically generated by the compiler under certain conditions. Rules for automatic generation of special member functions:

	Default constructor	Copy constructor	Copy operator=	Move constructor	Move operator=	Destructor
Nothing	YES	YES	YES	YES	YES	YES
Any constructor	NO	YES	YES	YES	YES	YES
Default constructor	NO	YES	YES	YES	YES	YES
Copy constructor	NO	NO*	YES*	NO	NO	YES
Copy operator=	YES	YES*	NO*	NO	NO	YES
Move constructor	NO	DELETED	DELETED	NO*	NO	YES
Move operator=	YES	DELETED	DELETED	NO	NO*	YES
Destructor	YES	YES*	YES*	NO	NO	NO*

YES: the special member function is defined by the compiler
NO: the special member function is not defined by the compiler
NO*: the special member function is not defined by the compiler since it is defined by the user
YES*: the special member function is defined by the compiler but this is deprecated and may be removed in the future
DELETED: the special member function is defined by the compiler as deleted

Several factors contributing to the slower performance:

Used std::vector<int> for managing dynamic arrays, simplifying resource management and avoiding manual memory management.
Utilized defaulted special member functions (= default) to leverage compiler-generated implementations for copy and move semantics.
Removed explicit destructors since std::vector automatically handles resource deallocation.

In other words, don’t do it, still on par with Python performance. Here is a Python version of the benchmark for comparison:

import time
import numpy as np

# Class with copy semantics
class DynamicArrayCopy:
    def __init__(self, size):
        self.data = np.zeros(size, dtype=int)

    def __copy__(self):
        new_copy = DynamicArrayCopy(len(self.data))
        new_copy.data = np.copy(self.data)
        return new_copy

# Class with move semantics
class DynamicArrayMove:
    def __init__(self, size):
        self.data = np.zeros(size, dtype=int)

    def __move__(self):
        new_move = DynamicArrayMove(len(self.data))
        new_move.data, self.data = self.data, None
        return new_move

def benchmark_copy(array_size, num_iterations):
    start_time = time.time()

    for _ in range(num_iterations):
        arr1 = DynamicArrayCopy(array_size)
        arr2 = arr1.__copy__()

    end_time = time.time()
    print(f"Copying duration: {(end_time - start_time) * 1000:.2f}ms")

def benchmark_move(array_size, num_iterations):
    start_time = time.time()

    for _ in range(num_iterations):
        arr1 = DynamicArrayMove(array_size)
        arr2 = arr1.__move__()

    end_time = time.time()
    print(f"Moving duration: {(end_time - start_time) * 1000:.2f}ms")

if __name__ == "__main__":
    array_size = 1000000
    num_iterations = 100

    benchmark_copy(array_size, num_iterations)
    benchmark_move(array_size, num_iterations)

Copying duration: 302.09ms
Moving duration: 195.20ms

What’s the point?

Type Systems

While several other languages and extensions support similar concepts, Rust is the most prominent language with an affine type system. The point of substructural type systems is resource management. “Move semantics allows an object, under certain conditions, to take ownership of some other object’s external resources. This is important in two ways:
Turning expensive copies into cheap moves. See my first answer for an example. Note that if an object does not manage at least one external resource (either directly, or indirectly through its member objects), move semantics will not offer any advantages over copy semantics. In that case, copying an object and moving an object means the exact same thing.
Implementing safe “move-only” types; that is, types for which copying does not make sense, but moving does. Examples include locks, file handles, and smart pointers with unique ownership semantics. Note: This answer discusses std::auto_ptr, a deprecated C++98 standard library template, which was replaced by std::unique_ptr in C++11. Intermediate C++ programmers are probably at least somewhat familiar with std::auto_ptr, and because of the “move semantics” it displays, it seems like a good starting point for discussing move semantics in C++11. YMMV.”
—Donald Duck

Affine types are a version of linear types imposing weaker constraints, corresponding to affine logic. An affine resource can be used at most once, while a linear one must be used exactly once.

Rust’s affine type system is a key component of its ownership model, ensuring memory safety and preventing data races at compile time without a garbage collector. In an affine type system, a value can be used at most once. This contrasts with a linear type system, where a value must be used exactly once. Rust’s affine type system enforces that values are either:

Moved: Transferred to another variable or context, meaning the original owner can no longer use the value.
Borrowed: Temporarily lent to another context, either immutably (read-only) or mutably (read-write).

A linear type system, unlike an affine type system, requires that values must be used exactly once. While Rust uses an affine type system, a language like Haskell with the LinearTypes extension can be used to demonstrate a linear type system. Below is an example of how you might use linear types in Haskell:

{-# LANGUAGE LinearTypes #-}

-- A simple linear function
linearFunction :: a %1 -> (a, a)
linearFunction x = (x, x)

main :: IO ()
main = do
    let (x1, x2) = linearFunction 42
    print x1
    -- print x2 -- Uncommenting this line will cause a compilation error

Rvalue references

Rvalue references are a key feature of C++ move semantics, allowing the binding of temporary objects to rvalue references. This feature enables the efficient transfer of resources from temporary objects to other objects, reducing the need for expensive deep copies. Rvalue references are denoted by && and can be used to bind to temporary objects that would otherwise be destroyed at the end of the expression.

    DynamicArrayMove(DynamicArrayMove &&other) noexcept: data(nullptr), size(0) {
        // Transfer ownership
        data = other.data;
        size = other.size;

        // Nullify the source object
        other.data = nullptr;
        other.size = 0;
    }

It is a good practice to mark move constructors as noexcept because it can help with performance optimizations. These initialize the data and size members of the current object to nullptr and 0, respectively. This is done to ensure that the current object starts with valid default values.

Perfect forwarding

Perfect forwarding is a C++ feature that allows functions to forward arguments to other functions while preserving the value category (lvalue or rvalue) and constness of the original arguments. This feature is essential for implementing generic functions and constructors that need to pass arguments to other functions without losing information about the original argument’s value category.

#include <iostream>
#include <utility> // for std::forward

void process(int& lvalue) {
    std::cout << "Lvalue reference\n";
}

void process(int&& rvalue) {
    std::cout << "Rvalue reference\n";
}

template <typename T>
void forwarder(T&& arg) {
    process(std::forward<T>(arg));
}

int main() {
    int x = 42;
    forwarder(x);        // Calls process(int&)
    forwarder(42);       // Calls process(int&&)
    forwarder(std::move(x)); // Calls process(int&&)
    return 0;
}

Deeper Dive

Smart pointers

Smart pointers are a key component of modern C++ programming, providing automatic memory management and resource handling. Smart pointers are a type of RAII (Resource Acquisition Is Initialization) object that automatically manages the lifetime of dynamically allocated resources. They are used to ensure that resources are properly deallocated when they are no longer needed, preventing memory leaks and resource leaks. std::unique_ptr in particular is closely related to move semantics in C++.

// Move constructor
std::unique_ptr<int> ptr1(new int(10));
std::unique_ptr<int> ptr2 = std::move(ptr1);  // ptr1 is moved to ptr2
// Now ptr1 is empty and ptr2 owns the int

// Move assignment operator
std::unique_ptr<int> ptr3(new int(20));
std::unique_ptr<int> ptr4;
ptr4 = std::move(ptr3);  // ptr3 is moved to ptr4
// Now ptr3 is empty and ptr4 owns the int

Non-nullable `std::unique_ptr`

The owning_ptr class template in C++ is a custom smart pointer that manages the lifetime of a dynamically allocated object of type T. Here’s a detailed explanation of its implementation based on Jonathan’s example.

#include <utility> // for std::move

template <typename T>
class owning_ptr
{
public:
    // Constructor to create and initialize the managed object
    template <typename ... Args>
    explicit owning_ptr(Args&&... args)
    : ptr_(new T(std::forward<Args>(args...))) {}

    // Destructor to clean up the managed object
    ~owning_ptr() { delete ptr_; }

    // Deleted copy constructor and copy assignment operator
    owning_ptr(const owning_ptr&)            = delete;
    owning_ptr& operator=(const owning_ptr&) = delete;

    // Move constructor
    owning_ptr(owning_ptr&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }

    // Move assignment operator
    owning_ptr& operator=(owning_ptr&& other) noexcept {
        if (this != &other) {
            delete ptr_;        // Clean up existing resource
            ptr_ = other.ptr_;  // Transfer ownership
            other.ptr_ = nullptr;
        }
        return *this;
    }

    // Overloaded dereference operator
    T& operator* () { return *ptr_; }

    // Overloaded arrow operator
    T* operator->() { return  ptr_; }

private:
    T* ptr_;
};

#include <iostream>

class MyClass {
public:
    MyClass(int x) : value(x) {}
    void display() const { std::cout << "Value: " << value << std::endl; }
private:
    int value;
};

int main() {
    owning_ptr<MyClass> p1(42); // Creates a MyClass object with the value 42
    p1->display();              // Accesses MyClass::display() through the smart pointer

    owning_ptr<MyClass> p2 = std::move(p1); // Move ownership to p2
    p2->display();              // Accesses MyClass::display() through the smart pointer

    owning_ptr<MyClass> p3(10); // Create another MyClass object with the value 10
    p3 = std::move(p2);         // Move ownership to p3
    p3->display();              // Accesses MyClass::display() through the smart pointer

    return 0;                   // MyClass object is automatically deleted
}

When implementing move semantics, it’s important to ensure that the object being moved from (the “source” object) is left in a valid state after the move operation. A common practice is to set the pointer in the source object to nullptr after transferring ownership, which signifies that the source no longer owns the resource. This helps prevent double deletion and ensures that the destructor of the source object does not attempt to delete the resource that has already been transferred.