Взаимодействие между задачами в Rust

Модель памяти Rust, в общем случае, не допускает совместного обращения к одной и той же памяти (shared model) предлагая вместо этого обмениваться сообщениями (mailbox model). При этом существует возможность работать с общей памятью в режимах “только для чтения” и “один писатель много читателей”. На данный момент в Rust существует несколько способов организации взаимодействия между задачами:

  • Низкоуровневые каналы и порты из модуля core::comm;
  • Высокоуровневая абстракция над каналами и портами std::comm;
  • Каналы предназначенные для передачи бинарных данных из std::flatpipes;
  • Новая инфраструктура для обмена сообщениями core::pipes.

Continue reading

Инициализация константных переменных

В Rust мне сразу понравилась возможность присваивать переменным результат оператора if. Подобных функционал очень полезен для инициализации константных переменных без введения дополнительных функций.

fn main() {
    let someFlag = false;
    let value = if someFlag {
        -1
    } else {
        1
    };
    io::println(fmt!("value == %d", value))
}

В случае же с C++, для того что бы инициализировать константную переменную приходилось вводить дополнительную функцию или, что чаще, плевать на константность и обходиться обычной переменной. Ну а с C++11 данная проблема решается куда проще

int main() {
    bool someFlag = false;
    const auto value = [&]{
        if(someFlag)
            return -1;
        else
            return 1;
    } ();
    std::cout << "value == " << value << std::endl;
    return 0;
}

Ну и конечно не забываем про то, что это C++11

 > clang++ -std=c++11 test.cpp

P.S. подсмотренно у Саттера.

Доступ к элементам кортежа

Да, несмотря на все плюсы модели памяти Rust, все же приходится признать – это для очень упорных программистов. В крайнем случае у меня создалось именно такое ощущение в процессе выяснения в “рассылке” как же мне написать функции доступа к элементам кортежа. В сам язык встроена следующая возможность:

fn foo() -> (uint, uint) { (1, 2) }
...
let (l, r) = foo();
io::println(fmt!("Left value = %u, write value = %u", l, r));

В то же время, мне хотелось получить доступ к элементу кортежа без дополнительных “приседаний”, где-то так:

let pair = foo();
io::println(fmt!("Left value = %u, write value = %u",
    pair._1(), pair._2()));

Continue reading

Модель памяти Rust

Модель памяти Rust довольно сильно отличается как от управляемых языков типа Java или C#, так и от не управляемых языков типа C и C++. Так как Rust является совершенно новым языком программирования и не ограничен какими-либо требованиями совместимости с предшественниками, он реализует наиболее удобную модель памяти для решения следующих целей:
Безопасность. Предотвращение возникновения утечек памяти или ошибок сегментации.
Производительность. Сборщик мусора управляет указателями а не объектами. Нет необходимости замораживать все задачи для очистки памяти, так как каждая из них имеет собственный хип.
Многопоточность. Предотвращение возникновения гонок в памяти, так как каждая из задач имеет собственный хип и передаваемые между задачами данные должны копироваться. Наличие хипа обмена для избежания лишних операций копирования с семантикой владения. Continue reading

Rust 0.3

Вышла новая версия языка Rust с номером 0.3. Несмотря на то, что говорить о каком бы то ни было коммерческом использовании языка рано, он обретает все более и более четкие формы, появляется понимание куда же он движется. Continue reading

Сборка Rust из репозитория

Очень часто, особенно в случае с рабочими машинами, доступ в интернет довольно жестко ограничен и почти все протоколы за исключением HTTP(S) заблокированы. Именно с такой проблемой я и столкнулся пытаясь собрать Rust. Все дело в том, что кроме основного модуля кодовой базы, который можно загрузить по HTTPS, у проекта есть два дополнительных подмодуля, для которых жестко заданна работа через протокол Git. В результате, в процессе сборки, я столкнулся с ошибкой:

configure: git: submodule status
-1170ffba3ac5191930b40c897d4569a9d8a296a3 src/libuv
-3a57b672f89adcb2d2d06adc564dc15ca4e276d6 src/llvm
configure: git: submodule update
fatal: unable to connect to github.com:
github.com[0: 207.97.227.239]: errno=Connection timed out

Continue reading

Классы в Rust

В Rust, зачем-то запихали классы. Видимо для того, что бы было “как у всех”. Ощущения от классов, мягко говоря, противоречивые. Хотя в рассылке и утверждают, что с тем, как классы будут выглядеть еще не определились, но ничто так не постоянно, как все временно. Итак, выглядит это дело следующим образом:

class test_class {
    priv {
        let mut val: int;
    }
    new(val: int) {
        self.val = val;
    }
    fn foo() {
        self.val += 1;
        io::println(#fmt("val+1 == %d", self.val));
    }
}

fn main() {
    let obj = test_class(10);
    obj.foo();
}

Любой класс должен иметь конструктор, в противном случае, компилятор скажет что-то типа следующего:

class.rs:14:0: 14:2 error: class with no ctor

В то же время, никаких подтверждений наличию деструкторов я не нашел. Полагаю, будут, но позже, а сейчас можно воспользоваться типом resource, пусть и будет выглядеть итоговое решение крайне криво.
Вторая не понравившаяся особенность классов, необходимость использовать self для доступа к членам из функций классов. Так же self используется для доступа к функциям класса, что выглядит как некий атавизм.
А в целом… Ну, классы, такие классы…

Перегрузка функций по параметрам. Часть 2.

В результате обсуждения в мэйл-листе Rust вопроса о перегрузке функций, родился еще один довольно занятный вариант:

enum input { int(int), str(str) }

iface to_input { fn to_input() -> input; }
impl of to_input for int { fn to_input() -> input { ret int(self); } }
impl of to_input for str { fn to_input() -> input { ret str(self); } }

fn to_input<T: to_input>(t: T) {
    alt t.to_input() {
        int(v) { io::println("int"); }
        str(v) { io::println("str"); }
    }
}

fn main() {
    to_input(5);
    to_input("hello")  
}

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

Управление памятью в Rust. Часть 2.

К сожалению, а может и к счастью, Rust не предоставляет возможности создать не управляемый объект в хипе. Так или иначе, объект будет управляться при помощи либо разделяемых, либо уникальных указателей. И в первом и во втором случаях, по входу последнего из указателей за пределы области видимости объект в памяти будет уничтожен. В довольно редких случаях, такое поведение не подходит. В качестве примера можно взять данные, передаваемые в качестве параметра для асинхронной функции в неуправляемую библиотеку.
Для решения подобной задачи остается только одно, выделить память при помощи malloc и не забыть освободить ее при помощи free. Ну и небольшой примерчик того, как облегчить себе жизнь.

unsafe fn mk_mem_obj_copy<T>(src: T) -> *T {
    let size = sys::size_of::<T>();
    let dst = libc::malloc(size);
    libc::memcpy(dst, ptr::addr_of(src) as *libc::c_void, size);
    ret dst as *T;
}

unsafe fn mk_mem_obj<T>() -> *T {
    libc::malloc(sys::size_of::<T>()) as *T
}

unsafe fn mem_obj_free<T>(obj: *T) {
    libc::free( obj as *libc::c_void );
}

Управление памятью в Rust.

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

type test_rec = {
    fld1: uint,
    fld2: str,
    fld3: char
};

Эксперимент 1. В руководстве по Rust сказано, что компилятор самостоятельно выбирает способ передачи параметров в функцию. Данные небольшого размера, например int копируются, данные большего размера, например записи, неявно передаются по ссылке.
Continue reading