1. 1. Introduction
  2. 2. Введение
  3. 3. C чего начать
  4. 4. Изучение Rust
    1. 4.1. Угадайка
    2. 4.2. Обедающие философы
    3. 4.3. Вызов кода на Rust из других языков
  5. 5. Синтаксис и семантика
    1. 5.1. Связывание имён
    2. 5.2. Функции
    3. 5.3. Простые типы
    4. 5.4. Комментарии
    5. 5.5. Конструкция `if`
    6. 5.6. Циклы
    7. 5.7. Владение
    8. 5.8. Ссылки и заимствование
    9. 5.9. Время жизни
    10. 5.10. Изменяемость
    11. 5.11. Структуры
    12. 5.12. Перечисления
    13. 5.13. Конструкция `match`
    14. 5.14. Шаблоны сопоставления `match`
    15. 5.15. Синтаксис методов
    16. 5.16. Вектора
    17. 5.17. Строки
    18. 5.18. Обобщённое программирование
    19. 5.19. Типажи
    20. 5.20. Типаж `Drop`
    21. 5.21. Конструкция `if let`
    22. 5.22. Типажи-объекты
    23. 5.23. Замыкания
    24. 5.24. Универсальный синтаксис вызова функций
    25. 5.25. Контейнеры и модули
    26. 5.26. `const` и `static`
    27. 5.27. Атрибуты
    28. 5.28. Псевдонимы типов
    29. 5.29. Приведение типов
    30. 5.30. Ассоциированные типы
    31. 5.31. Безразмерные типы
    32. 5.32. Перегрузка операций
    33. 5.33. Преобразования при разыменовании
    34. 5.34. Макросы
    35. 5.35. Сырые указатели
    36. 5.36. Небезопасный код
  6. 6. Эффективное использование Rust
    1. 6.1. Стек и куча
    2. 6.2. Тестирование
    3. 6.3. Условная компиляция
    4. 6.4. Документация
    5. 6.5. Итераторы
    6. 6.6. Многозадачность
    7. 6.7. Обработка ошибок
    8. 6.8. Выбор гарантий
    9. 6.9. Интерфейс внешних функций
    10. 6.10. Типажи `Borrow` и `AsRef`
    11. 6.11. Каналы сборок
    12. 6.12. Using Rust without the standard library
  7. 7. Нестабильные возможности Rust
    1. 7.1. Плагины к компилятору
    2. 7.2. Встроенный ассемблерный код
    3. 7.3. Без stdlib
    4. 7.4. Внутренние средства
    5. 7.5. Элементы языка
    6. 7.6. Продвинутое руководство по компоновке
    7. 7.7. Тесты производительности
    8. 7.8. Синтаксис упаковки и шаблоны `match`
    9. 7.9. Шаблоны `match` для срезов
    10. 7.10. Ассоциированные константы
    11. 7.11. Пользовательские менеджеры памяти
  8. 8. Глоссарий
  9. 9. Syntax Index
  10. 10. Библиография

Вызов кода на Rust из других языков

Для нашего третьего проекта мы собираемся выбрать что-то, что подчеркнёт одну из самых сильных сторон в Rust: фактическое отсутствие среды исполнения.

По мере роста организации, программисты все больше полагаются на множество языков программирования. У каждого языка программирования есть свои сильные и слабые стороны, а знание нескольких языков позволяет использовать определённый язык там, где проявляется его сильные стороны, и использовать другой язык там, где первый не очень хорош.

Существует несколько областей, где многие языки программирования слабы в плане производительности выполнения программ. Часто компромисс заключается в том, чтобы использовать более медленный язык, который взамен способствует повышению производительности программиста. Чтобы решить эту проблему, часть кода системы можно написать на C, а затем вызвать этот код, написанный на C, как если бы он был написан на языке высокого уровня. Это называется «интерфейс внешних функций» (foreign function interface), часто сокращается до FFI.

Rust включает поддержку FFI в обоих направлениях: он легко может вызвать C код, и он так же легко, как и C код, может быть вызван извне. Rust сочетает в себе отсутствие сборщика мусора и низкие требования к среде исполнения, что делает Rust отличным кандидатом на роль вызываемого из других языков, когда нужны некоторые дополнительные возможности.

В этой книге есть целая глава, посвящённая FFI и его специфике, а в этой главе мы рассмотрим именно конкретный частный случай FFI, с тремя примерами, на Ruby, Python и JavaScript.

Проблема

Есть много различных проектов, которые мы могли бы выбрать, но мы хотим подобрать такой пример, который продемонстрирует явное преимущество Rust над многими другими языками: сложные вычисления и многопоточность.

Во многих языках числа размещаются в куче, а не в стеке. Это обеспечивает целостность поведения языка при работе с числами и с другими объектами. Особенно в языках, которые сосредотачиваются на объектно-ориентированном программировании и использовании сборщика мусора, по умолчанию память выделяется из кучи. Иногда, при оптимизации, для конкретных чисел память может выделяться в стеке, но вместо того, чтобы полагаться на работу оптимизации, мы можем захотеть убедиться в том, что мы используем примитивные типы чисел, а не какой-либо тип объекта.

Во-вторых, многие языки имеют «глобальную блокировку интерпретатора» (global interpreter lock), которая ограничивает параллелизм во многих ситуациях. Это делается во имя безопасности, что оказывает положительный эффект, но это также и ограничивает объем работ, который может быть выполнен одновременно, что, в свою очередь, оказывает большой отрицательный эффект.

Чтобы подчеркнуть эти два аспекта, мы собираемся создать небольшой проект, который в значительной степени их использует. Поскольку внимание в этом примере сфокусировано на встраивание Rust в другие языки, а не самой проблеме, мы будем использовать игрушечный пример:

Запустить десять потоков. Внутри каждого потока считать от одного до пяти миллионов. После того как все десять потоков завершатся, напечатать "сделано!".

Мы выбрали пять миллионов руководствуясь тем, сколько времени занимает эта работа на современном компьютере. Вот пример этого кода на Ruby:

threads = []

10.times do
  threads << Thread.new do
    count = 0

    5_000_000.times do
      count += 1
    end
  end
end

threads.each { |t| t.join }
puts "сделано!"

Попробуйте запустить этот пример, и подберите число, которое обеспечит работу в течение нескольких секунд. В зависимости от аппаратного обеспечения компьютера, возможно, придётся увеличить или уменьшить это число.

На выбранной нами системе эта программа работает 2.156 секунд. И если мы воспользуемся какой-нибудь утилитой для мониторинга процессов (например, top), то увидим, что она использует только одно ядро. Это GIL делает своё дело.

Хотя это и игрушечная программа, на её примере можно продемонстрировать много проблем, аналогичных этой, характерных для реального мира. Для наших целей, долго крутящиеся занятые потоки представляют собой параллельные, требующие больших затрат, вычисления.

Библиотека на Rust

Давайте перепишем эту задачу на Rust. Во-первых, давайте сделаем новый проект с помощью Cargo:

$ cargo new embed
$ cd embed

Эту программу легко переписать на Rust:

use std::thread;

fn process() {
    let handles: Vec<_> = (0..10).map(|_| {
        thread::spawn(|| {
            let mut x = 0;
            for _ in 0..5_000_000 {
                x += 1
            }
            x
        })
    }).collect();

    for h in handles {
        println!("Поток завершился со счётом={}",
        h.join().map_err(|_| "Не удалось соединиться с потоком!").unwrap());
    }
}Run

Мы уже знакомы с частью этого кода из предыдущих примеров. Мы создаём десять потоков, собирая их в вектор handles. Внутри каждого потока мы осуществляем пять миллионов повторений в цикле, и прибавляем к x единицу каждый раз. Наконец, мы воссоединяем все потоки.

Сейчас, однако, это просто библиотека Rust, которая не включает все необходимое для успешного вызова из другого языка. Если мы попытаемся подключить её к другому языку в том виде, в котором она сейчас, то это не будет работать. Нам нужно сделать два небольших изменения, чтобы исправить это. Первое, что мы должны сделать, это изменить начало нашего кода:

#[no_mangle]
pub extern fn process() {Run

Мы добавили новый атрибут, no_mangle. В процессе создания библиотеки Rust, в выходном скомпилированном файле происходит изменение имени функции. Причины этого выходят за рамки данного руководства, но для того, чтобы и другие языки знали, как вызвать функцию, мы должны не делать этого. Указанный атрибут выключает такое поведение.

Другим изменением, которое мы добавили, является pub extern. pub означает, что эта функция может быть вызвана за пределами этого модуля, а extern говорит, что её возможно вызвать из С. Вот и все! Не так и много изменений.

Второе, что мы должны сделать, это изменить настройки в Cargo.toml. Добавьте это в конец файла:

[lib]
name = "embed"
crate-type = ["dylib"]

Это говорит Rust, что мы хотим скомпилировать нашу библиотеку в виде стандартной динамической библиотеки. По умолчанию, Rust компилирует в rlib, Rust- специфичный формат.

Давайте теперь соберём проект:

$ cargo build --release
   Compiling embed v0.1.0 (file:///home/steve/src/embed)

Мы ввели команду cargo build --release, которая выполняет сборку с включённой оптимизацией. Мы хотим, чтобы код был как можно более быстрым! Вы можете найти собранную библиотеку в target/release:

$ ls target/release/
build  deps  examples  libembed.so  native

Файл libembed.so — и есть наша динамическая библиотека (shared object). Мы можем использовать этот файл также как и любую другую динамическую библиотеку, написанную на C! Попутно следует отметить, это может быть embed.dll (Microsoft Windows) или libembed.dylib (Mac OS X), в зависимости от операционной системы.

Теперь, когда мы получили нашу собранную библиотеку Rust, давайте используем её из нашего кода на Ruby.

Ruby

Откройте файл embed.rb внутри нашего проекта, и сделайте следующее:

require 'ffi'

module Hello
  extend FFI::Library
  ffi_lib 'target/release/libembed.so'
  attach_function :process, [], :void
end

Hello.process

puts 'сделано!'

Прежде чем мы сможем запустить этот код, нам нужно установить пакет ffi:

$ gem install ffi # this may need sudo
Fetching: ffi-1.9.8.gem (100%)
Building native extensions.  This could take a while...
Successfully installed ffi-1.9.8
Parsing documentation for ffi-1.9.8
Installing ri documentation for ffi-1.9.8
Done installing documentation for ffi after 0 seconds
1 gem installed

И, наконец, мы можем попробовать запустить его:

$ ruby embed.rb
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
Поток завершился со счётом=5000000
сделано!
$

Ничего себе, это было быстро! На моей системе это заняло 0.086 секунд, а не две секунды как это было на чистом Ruby. Давайте разберём этот Ruby код:

require 'ffi'

Первый делом, нам надо объявить пакет ffi. Он предоставляет нам интерфейс для использования нашей библиотеки на Rust, как библиотеку на C.

module Hello
  extend FFI::Library
  ffi_lib 'target/release/libembed.so'

Автор пакета ffi рекомендует использовать модуль, чтобы ограничить область действия функции, которую мы импортировали из разделяемой библиотеки. Внутри мы указали extend, чтобы воспользоваться необходимым модулем FFI::Library, а затем вызвали ffi_lib, чтобы подгрузить нашу библиотеку. Мы просто передаём путь к библиотеке, который мы уже видели раньше, это target/release/libembed.so.

attach_function :process, [], :void

Метод attach_function предоставляется пакетом FFI. Здесь соединяются наша функция process(), написанная на Rust, и одноимённая функция на Ruby. Так как process() не принимает аргументов, второй параметр является пустым массивом, и поскольку функция ничего не возвращает, мы передаём :void в качестве завершающего аргумента.

Hello.process

Здесь мы совершаем вызов нашей Rust функции. Сочетание нашего module и вызова к attach_function завершает подготовку. Это выглядит как функция Ruby, но на самом деле это Rust!

puts 'сделано!'

Наконец, в соответствие с нашими требованиями к проекту, мы пишем сделано! по окончанию работы программы.

Вот и все! Как мы увидели, совместить два языка очень просто, и взамен мы получили большую производительность.

Теперь давайте попробуем на Python!

Python

Создайте файл embed.py в этой директории и поместите в него следующее:

from ctypes import cdll

lib = cdll.LoadLibrary("target/release/libembed.so")

lib.process()

print("сделано!")

Довольно просто! Мы импортируем cdll из модуля ctypes. Затем вызываем LoadLibrary. И теперь мы можем вызвать process().

На моей системе это заняло 0.017 секунд. Быстро!

Node.js

Node — это не язык, но, в настоящее время, это доминирующая реализация исполнения JavaScript на сервере.

Для того, чтобы сделать FFI в Node, нам сначала надо установить библиотеку:

$ npm install ffi

После установки, мы можем ей воспользоваться:

var ffi = require('ffi');

var lib = ffi.Library('target/release/libembed', {
  'process': ['void', []]
});

lib.process();

console.log("сделано!");

Пример больше похож на Ruby, чем на Python. Мы используем модуль ffi, чтобы получить доступ к ffi.Library(), который загружает нашу библиотеку. Нам нужно указать тип возвращаемого значения и типы аргументов функции: void для возвращаемого значения и пустой массив для указания отсутствия аргументов. После этого мы просто вызываем функцию и печатаем результат.

На моей системе это заняло 0.092 секунды.

Заключение

Как вы можете видеть, основы, рассмотренные здесь, являются очень простыми. Конечно, мы могли бы сделать куда больше того, что мы здесь показали. Посмотрите главу FFI для более подробной информации.