Hablaremos del modelo de pertenencia que Rust ofrece y por qué es una de las aportaciones más importantes que un lenguaje ha ofrecido recientemente. Rust promete un nivel de desempeño similar o mejor a C o C++, pero con las abstracciones de alto nivel a las que uno esta acostumbrado en lenguajes como Java o Ruby. esión presentada por Norberto Ortigoza en SG Next 2017

1. Rust: manejo de
memoria y
colectores de basura
@Hiphoox
norberto@bunsan.io

2. Agenda
•Estrategias de manejo de memoria.
•Modelo de Rust.
•Conclusiones.

3. Estrategias de administración de
memoria
C, C++, Objective-C/Swift, Ruby, Python, Java, Rust

4. Estrategías
•Manual (malloc/free).
•Automática.

5. Manual
• Operaciones:
•Malloc/Free
Casos de uso:
•Embedded systems.
•Real time systems.
•Game engines.

6. Automática
Estrategias
•Reference Counting (Objective-C, Swift, Python)
•Tracing Garbage Collectors (Java, Ruby)
•Smart Pointers/RAII (Resource Acquisition Is Initialization; C++)
•Ownership (Rust)

7. Reference Counting
•Operaciones:
•release
•retain
•autorelease
•Contadores atómicos y no atómicos
•Casos de uso:
•Latencia
•Bajo consumo de memoria

8. Tracing Garbage Collectors
(invented by John McCarthy in 1958)
•Algoritmos:
•Mark &Sweep
•Tri-color
•Tipos de Colectores:
•Boehm–Demers–Weiser
•Generacionales
•Incrementales, concurrentes y stop-the-world
•Casos de uso
•Enterprise systems

9. Smart Pointers/RAII
C++ 11
•Operaciones:
•unique_ptr
•shared_ptr
•weak_ptr
Casos de uso:
•Embedded systems.
•Real time systems.
•Game engines.

10. Comparación
Elementos a evaluar
•Velocidad de ejecución
•Consumo de memoria
•Facilidad de uso
•Determinístico o no determinístico
•Runtime o compile time
•Latency

11. Comparación
Características
Manual
Reference
Counting
Garbage Collector
Smart pointer con
RAII
Velocidad de ejecución
Excelente con
optimización
Muy Buena
Muy buena con
algunas excepciones
Excelente
Consumo de memoria
Poca con
optimización
Poca Regular Poca
Facilidad de uso Complejo
Regular (Ciclos de
retención)
Fácil Regular
Determinístico/
predecible
Si/Si Si/Si Depende/No Si/Si
Runtime o compile-
time
NA
Compile con algo
manual
Runtime Compile
Manejo de recursos No No No Si
Latencia Constante Constante Variable Constante

12. Comparación
Lenguajes
Manual
Reference
Counting (ARC)
Garbage Collector Ownership
Smart pointer con
RAII
Swift/Objective-C X
Java X
Ruby X
Python X
Rust X ? X
C/C++ X X
Erlang/Elixir X X
Go X

13. Modelo de Rust
ownership

14. – Rust Team
“Rust wants safe (not vulnerabilities) memory
and resource management without garbage
collection”

15. Rust
características
•Tipado estático con inferencia de tipos.
•No clases. :-)
•Pattern matching.
•Funciones de grado superior.
•Modelo de concurrencia basado en canales.
•Inmutable.

16. Rust
características
•En Rust, como en otros lenguajes con colector de basura, no tienes que liberar de
forma explicita la memoria.
•En Rust, a diferencia de lenguajes con colectores de basura, no necesitas cerrar o
liberar recursos como archivos, sockets y locks.
•Rust logra estos dos puntos sin costos en tiempo de ejecución (colector de basura
o conteo de referencias), y sin sacrificar seguridad.

17. Rust
ownership
•El scope se hace dueño del recurso o memoria.
•Al terminar el scope el recurso o memoria se libera.
•Se puede transferir la propiedad de un recurso o memoria a otra función.

18. Rust
Ejemplo
fn main() {
let s1 = String::from("hello");
let len = calculate_length(s1);
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: String) -> usize {
s.len()
}
¡Error!

19. Rust
ownership
•Se puede prestar el recurso a otro scope

20. Rust
Ejemplo
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1);
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
¡Si funciona!

21. Rust
Ventajas
•Este mecanismo funciona para:
•Automatic memory management
•Automatic resource management

22. Rust
Resumen
•En cualquier momento, puedes tener cualquiera de estas opciones pero no ambas:
•Una referencia mutable.
•Cualquier número de referencias no mutables.
•Las referencias siempre son validas.

23. Comparación
Tipos de manejo de memoria
Manual
Reference
Counting
Garbage
Collector
Ownership
Smart pointer /
RAII
Velocidad de
ejecución
Excelente con
optimización
Buena
Muy buena con
casos especiales
Excelente Excelente
Consumo de
memoria
Poca con
optimización
Poca Regular Poca Poca
Facilidad de uso Complejo
Regular (Ciclos de
retención)
Fácil Regular/Fácil Regular
Determinístico/
predecible
Si/Si Si/Si Depende/No Si/Si Si/Si
Runtime o
compile-time
NA
Compile con algo
manual
Runtime Compile Compile
Manejo de
recursos
No No No Si Si
Latencia Constante Constante Variable Constante Constante

24. Conclusiones

25. Conclusiones
• Siempre debes pensar en tu consumo de
memoria.
• Conoce que estrategia emplea tu lenguaje de
programación.
• Manejo automático de memoria no es igual a no
preocuparse por como tu programa la usa.
• GC son MUY rápidos.
• GC son muy buenos eliminando grupos de
objetos.

26. Conclusiones
• Rust es una alternativa viable para tener control
sobre el uso de memoria y el mecanismo para
administrarla.
• Rust es extremadamente rapido.
• Si tienes un problema donde C o C++ sea la
opción, evaluar mejor usar Rust :-)
• Rust es estable y en fase de creación de
bibliotecas :-)

27. ¿Preguntas?
@hiphoox
norberto@bunsan.io