Документ обсуждает компилируемые в реальном времени языки, ориентированные на конкретные предметные области (DSL) для C++, включая их преимущества и недостатки, а также примеры архитектуры и реализации. Приведены детали о синтаксическом анализе, кодогенерации и производительности различных решений. Описаны классы AST и их реализация, а также сравнительный анализ производительности различных подходов.

1. Компилируемые в реальном
времени DSL для С++
Юрий Ефимочев

2. О себе
Архитектор в LogicNow
Специализация: высоконагруженные
отказоустойчивые системы на C++
Бэкап-решение

3. Что такое DSL?
Domain-specific language - это язык программирования с
ограниченными возможностями, ориентированный на конкретную
предметную область.

4. Достоинства и недостатки DSL
Достоинства:
• управление сложностью
• скорость разработки
• комуникация с экспертами
• альтернативные парадигмы
• динамическое выполнение
Недостатки:
• порог вхождения
• эволюция в язык общего назначения
• разработка и поддержка

5. Классификация DSL
• Внутренние
• Внешние
• Визуальные
• Интерпретируемые
• Компилируемые

6. Пример: тестирование
Given(
Node("a")
(Node("b")
(Node("c"))
(Node("d")))
(Node("e")
(Node("f"))
(Node("g"))));
When().Filter("%f%");
Expect(
Node("a")
(Node("e")
(Node("f"))));
a
b
c d
e
f g
a
e
f

7. Архитектура DSL
Программа
на
DSL
Семантическая
модель
Целевой
код
Опционально

8. Постановка задачи
Дано:
~ 100 000 объектов
~ 500 параметров у объекта
Требуется:
получение актуальной статистики по произвольной
выборке объектов

9. Примеры запросов
Count(true)
Count(LastSession.Timestamp < 2.days().ago())
Count(Version like ‘15.12.%’)
Count(LastSession.Status == SessionStatus::Failed)
Average(LastSession.Duration)
Sum(UsedStorage)

10. Архитектура решения
Expression AST Result
Data

11. Синтаксический анализ
Инструментарий:
• flex & bison
• antlr
• boost::spirit

12. Синтаксический анализ
%start Start;
AtomicExpression:
IntegerNumber { $$.Value = m_builder.CreateInteger($1.Name); } |
Identifier { $$.Value = m_builder.CreateVariable($1.Name) };
AddSubExpression:
AtomicExpression |
AddSubExpression Plus AddSubExpression { m_builder.CreateAddNode(...);
} |
AddSubExpression Minus AddSubExpression { m_builder.CreateSubNode(...);
};
Start:
AddSubExpression { result.AstTree.reset($1.Value); };

13. AST
Count(time > 2.days().ago()) Count
time ago
days
2
>
2.days().ago() = now - 2.days()
2.days() = 2 * 86400

14. AST
Count(time > 2.days().ago()) Count
time -
*
86400
>
now
2.days().ago() = now - 2.days()
2.days() = 2 * 86400
2

15. Реализация объектов AST
class IntegerNode : public IAstNode
{
public:
IntegerNode(int const value) :
m_value(value)
{
}
private:
virtual Variant Compile(IDataProvider& /*dataProvider*/) const
{
return Variant(m_value);
}
int const m_value;
};

16. Реализация объектов AST
class VariableNode : public IAstNode
{
public:
VariableNode(std::string const& name) :
m_name(name)
{
}
private:
virtual Variant Compile(IDataProvider& dataProvider) const
{
return Variant(dataProvider.GetVariableValue(m_name));
}
private:
std::string const m_name;
};

17. Реализация объектов AST
class AddNode : public IAstNode
{
public:
AddNode(IAstNodePtr left, IAstNodePtr right) :
m_left(std::move(left)),
m_right(std::move(right))
{
}
private:
virtual Variant Compile(IDataProvider& dataProvider) const
{
return m_left->Compile(dataProvider) + m_right->Compile(dataProvider);
}
private:
IAstNodePtr m_left;
IAstNodePtr m_right;
};

18. AST
Count(time > 2.days().ago()) Count
time -
*
86400
>
now
2.days().ago() = now - 2.days()
2.days() = 2 * 86400
2

19. Архитектура LLVM

20. Что такое LLVM IR?
Особенности:
• обобщенная система команд
• функции
• типы данных
• простые типы
• указатели
• массивы
• статическая типизация
• SSA(static single assignment) нотация

21. LLVM IR
bool MoveNext();
int GetValue();
int main()
{
int sum = 0;
while (MoveNext())
{
sum += GetValue();
}
return sum;
}
1 declare i1 @move_next()
2 declare i64 @get_value()
3
4 define i64 @main()
5 {
6 entry:
7 br label %loop_condition
8
9 loop_condition:
10 %1 = phi i64 [ 0, %entry ], [ %4, %loop_body ]
11 %2 = call i1 @move_next()
12 br i1 %2, label %loop_body, label %loop_exit
13
14 loop_body:
15 %3 = call i64 @get_value()
16 %4 = add i64 %3, %1
17 br label %loop_condition
18
19 loop_exit:
20 ret i64 %1
21 }

22. Архитектура решения
Expression AST
LLVM
IR AST
Native
code
Data
descriptor
Data
provider
Result
Data

23. Реализация AST
class IntegerNode : public IAstNode
{
public:
IntegerNode(int const value) :
m_value(value)
{
}
private:
virtual CompiledNode Compile(IDataProvider& context) const
{
return CompiledNode(DataType::Integer, context.GetBuilder().getInt64(m_value));
}
int const m_value;
};

24. Реализация AST
class VariableNode : public IAstNode
{
public:
VariableNode(std::string const& name) :
m_name(name)
{
}
private:
virtual CompiledNode Compile(ICompilationContext& context) const
{
return context.GetVariable(m_name);
}
private:
std::string const m_name;
};

25. Реализация AST
class AddNode : public IAstNode
{
public:
AddNode(IAstNodePtr left, IAstNodePtr right) :
m_left(std::move(left)),
m_right(std::move(right))
{
}
private:
virtual CompiledNode Compile(ICompilationContext& context) const
{
CompiledNode left = m_left->Compile(context);
CompiledNode right = m_right->Compile(context);
DataType::Enum const effectiveType = GetEffectiveType(left, right);
return CompiledNode(effectiveType, context.GetBuilder().CreateAdd(left, right));
}
private:
IAstNodePtr m_left;
IAstNodePtr m_right;
};

26. Производительность
Interpreted 1734 мс
LLVM 31 мс
LLVM(precompiled) 28 мс
Native 21 мс
Count(x < 50 && x > 22 || x == 77), size = 1000000

27. Кодогенерация
Инструментарий:
• LLVM
• Lua
• Chrome V8

28. Производительность
Interpreted 1734 мс
Lua 309 мс
Lua(precompiled) 276 мс
LLVM 31 мс
LLVM(precompiled) 28 мс
Native 21 мс
Count(x < 50 && x > 22 || x == 77), size = 1000000

29. Итоги
Плюсы:
• простота
• скорость разработки
• Производительность
Минусы:
• размер бинарного файла (~ 15 Mb)
• реализация местами сложна
• нативный код

30. ?