1. Введение
2. Синтаксис языка
3. Оптимизации по синтаксическому дереву
   1. Список задач
   2. 1 * expr, expr * 1, expr / 1, 0 + expr
   3. 2 * 3
   4. 0 * expr, expr * 0
   5. a - a
   6. 2 < 3
   7. 2 == 4
   8. a == a, a >= a
   9. a > a, a != a
   10. x = x
   11. if (true) st1; else st2;
   12. if (false) st1; else st2;
   13. if (expr) null; else null;
   14. while (false) st;
4. Генерация трехадресного кода. Построение ББл и CFG
   1. Список задач
   2. Архитектура системы оптимизаций
   3. Генерация трехадресного кода для всех конструкций
   4. Создание структуры ББл и CFG - графа ББл
   5. Разбиение на ББл + слияние ББл
   6. Архитектура системы тестирования оптимизаций
   7. Вычисление передаточной функции для достигающих определений композицией передаточных функций команд
5. Оптимизации базовых блоков
   1. Список задач
   2. Живые и мертвые переменные и удаление мертвого кода (замена на пустой оператор)
   3. Учет алгебраических тождеств
   4. Протяжка констант. Протяжка копий
   5. Оптимизация общих подвыражений
   6. Устранение переходов через переходы
   7. Def-Use информация: накопление информации и удаление мертвого кода на ее основе
   8. Свертка констант
   9. Устранение переходов к переходам. Удаление пустых операторов
6. Итерационные алгоритмы
   1. Список задач
   2. Итерационный алгоритм в структуре распространения констант
   3. Доступные выражения
   4. Разработка альтернативной реализации хранения IN и OUT в виде битовых векторов. Интеграция этого представления в ит. алг. о дост. опр.
   5. Активные переменные
   6. Достигающие определения
   7. Передаточная функция в структуре распространения констант
   8. Итерационный алгоритм в обобщённой структуре
7. Циклы в графах потоков управления
   1. Список задач
   2. Построение дерева доминаторов - итерационный алгоритм для определения D(B) + непосредственные доминаторы |
   3. Алгоритм упорядочения в глубину с построением глубинного остовного дерева
   4. Классификация ребер графа: наступающие, отступающие, поперечные (по построенному остовному дереву)
   5. Обратные ребра и определение того, что CFG является приводимым
   6. Определение всех естественных циклов

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

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

Грамматические правила используются для распознавания последовательности лексем и выполнения подходящих действий. В основном грамматические правила используются в комбинации с lex; оба эти инструмента - yacc и lec - и составляют анализатор.

Проект выполнен на языке C#.

exprlist    : expr
                {
                    $$ = new ListExprNode($1);
                }
            | exprlist COMMA expr
                {
                    $1.Add($3);
                    $$ = $1;
                }
            ;

--

На этом этапе оптимизации используется такая форма представления программы, которая более приспособленна для анализа, дальнейших преобразований и генерации кода. Мы будем переводить текст программы в так называемое синтаксическое дерево. Если синтаксическое дерево построено, то программа синтаксически правильная, и ее можно подвергать дальнейшей обработке. В синтаксическое дерево включаются узлы, соответствующие всем синтаксическим конструкциям языка. Атрибутами этих узлов являются их существенные характеристики. Например, для узла оператора присваивания AssignNode такими атрибутами являются IdNode - идентификатор в левой части оператора присваивания и ExprNode - выражение в правой части оператора присваивания. Синтаксическое дерево программы (или AST - Abstract Syntax Tree) отличается от дерева разбора тем, что в него не добавляются несущественные атрибуты - например, ключевые слова.

В yacc-файл, помимо грамматики, было добавлены семантические правила, которые записаны после правил грамматики в фигурных скобках и являются командами, конструирующими узлы синтаксического дерева. Синтаксическое дерево строится снизу вверх: вначале строятся листовые узлы, не имеющие потомков (например, IdNode или IntNumNode), затем по ним строятся другие узлы (например, AssignNode - по IdNode и ExprNode). Стратегия построения синтаксического дерева снизу вверх соответствует стратегии разбора снизу-вверх, принятой в парсере gppg (точнее, во всех парсерах, поддерживающих LR-грамматики). Корень синтаксического дерева записывается в поле root класса Parser.

Примечание: Здесь также описана задача №4

1. Команда, реализующая задачу Манукян Г. А.

2. Зависимые и предшествующие задачи

   Предшествующая:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Основная цель данной оптимизации – при помощи Визиторов заменить в узлах синтаксического дерева программы все алгебраически тождественные действия, то есть не меняющие результата после применения операции, на значение переменной (неизмененной) – умножение переменной слева (справа) на единицу, деление на единицу, прибавление нуля. Любая комбинация данных действий также устраняется до значения переменных, в условных операторах и так далее:

До:
c = c/(c/1);
if 2*1
...
if 1*2 > 0
...
q = 0 + c;
q = c + 0;
После:
c = c/c;
if 2
...
if 2 > 0
...
q = c;
q = c

4. Теория

Абстрактное синтаксическое дерево (АСД, англ. AST — Abstract Syntax Tree) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Семантическое дерево – «украшенное» синтаксическое, то есть содержащее дополнительную информацию (об операторе, инструкции и так далее) Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

В соответствии с целью оптимизации, узел дерева, содержащий тождественную операцию, заменяется на новый узел, с другим операндом, который также может содержать тождественную операцию. Для этого реализован паттерн «Визитор», В отдельных классах AlgebraicIdentityProdDiv1Visitor и AlgebraicIdentitySum0Visitor описаны методы Visit, заменяющие (рекурсивно) выражения в узлах AST: Пример 1*ex, ex*1, ex/1.

<...> case BinOpType.Prod:
if (BinOp.Left is IntNumNode && (BinOp.Left as IntNumNode).Num == 1)
{
    BinOp.Right.Visit(this);
    ReplaceExpr(BinOp, BinOp.Right);
}
else if (BinOp.Right is IntNumNode && (BinOp.Right as IntNumNode).Num == 1)
{
    BinOp.Left.Visit(this);
    ReplaceExpr(BinOp, BinOp.Left);
}
else base.Visit(BinOp); break; // После замены вызывается base.визитор - конвейер
case BinOpType.Div:
if (BinOp.Right is IntNumNode && (BinOp.Right as IntNumNode).Num == 1)
{
    BinOp.Left.Visit(this);
    ReplaceExpr(BinOp, BinOp.Left);
} 
break;
default:
base.Visit(BinOp); // После замены вызывается base.визитор от BinOp
break; 

6. Интеграция в общий проект

[TestCase("a = exp * 1;", "a = exp;")]
[TestCase("a = 1 * exp;", "a = exp;")]
[TestCase("a = b / 1;", "a = b;")]
[TestCase("a = c + 0;", "a = c;")]
[TestCase("a = 0 + d;", "a = d;")]
[TestCase("a = c/c/1*1*1/1;", "a = c/c;")]
[TestCase("a = 0 + c + 0*1;", "a = c;")]
public void OneLineTests(string line, string expected)
{
    var parser = GenerateTree(@"{" + $"\n{line}\n" + @"}");
    var expectedTree = GenerateTree(@"{" + $"\n{expected}\n" + @"}");
    var ProdDiv = new AlgebraicIdentityProdDiv1Visitor();
    var Sum = new AlgebraicIdentitySum0Visitor();
    ProdDiv.Visit(parser.root);
    Sum.Visit(parser.root);
    var actual = parser.ToString();
    var expect = expectedTree.ToString();
    Assert.AreEqual(actual, expect);
}

[Test]
public void AllDividedTestCasesTest()
{
    var Text = (@"{
a = 1;
b = 1;
c = 0;
c = c/c/1;
if 1*a + 1*b
{
c = a * b * 1;
}
q = a/1 + 5;
q = c + 0;
}");
    Scanner scanner = new Scanner();
    scanner.SetSource(Text, 0);
    Parser parser = new Parser(scanner);
    parser.Parse();

    var parentFiller = new FillParentsVisitor();
    parser.root.Visit(parentFiller);

    var ProdDiv = new AlgebraicIdentityProdDiv1Visitor();   
    var Sum = new AlgebraicIdentitySum0Visitor();

    ProdDiv.Visit(parser.root);
    Sum.Visit(parser.root);
    var prettyPrinter = new PrettyPrinterVisitor();

    parser.root.Visit(prettyPrinter);

    var TAC = GenerateTAC(prettyPrinter.FormattedProgram);

    var expected = new List<string>()
    {
        "a = 1",
        "b = 1",
        "c = 0",    
        "#t0 = c / c",
        "c = #t0",  
        "#t1 = a + b",
        "if #t1 goto #L0",
        "goto #L1",
        "#L0",
        "#t2 = a * b",
        "c = #t2",
        "#L1",
        "#t3 = a + 5",
        "q = #t3",
        "q = c"
    };

    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Погорелов А. А., Домбровская А. В.

2. Зависимые и предшествующие задачи

   Предшествующая:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

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

До:
x = 2 * 3 + 4;
После:
x = 10;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен. 5. Реализация

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

if (n is BinExprNode node)
{
    if (node.Left is IntNumNode leftInt && node.Right is IntNumNode rightInt)
    {
            if (node.OpType == BinOpType.Div)
        {
            ReplaceExpr(node,new IntNumNode(leftInt.Num / rightInt.Num));
        }
        if (node.OpType == BinOpType.Prod)
        {
            ReplaceExpr(node, new IntNumNode(leftInt.Num * rightInt.Num));
        }
        if (node.OpType == BinOpType.Minus)
        {
            ReplaceExpr(node, new IntNumNode(leftInt.Num - rightInt.Num));
        }
        if (node.OpType == BinOpType.Plus)
        {
            ReplaceExpr(node, new IntNumNode(leftInt.Num + rightInt.Num));
        }
    }
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью ConstantFoldingVisitor- оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Пример:

[Test]
public void SimpleExample2()
{
    var Text = (
@"
{
x = 7 - 8 * 0 + 3;
}
");
    Scanner scanner = new Scanner();
    scanner.SetSource(Text, 0);
    Parser parser = new Parser(scanner);
    parser.Parse();
    var parentFiller = new FillParentsVisitor();
    parser.root.Visit(parentFiller);

    var optimizer = new ConstantFoldingVisitor();
    parser.root.Visit(optimizer);

    var TACGenerator = new TACGenerationVisitor();
    parser.root.Visit(TACGenerator);
    var TAC = TACGenerator.TAC;

    var expected = new List<string>()
        {
            "x = 10"
        };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гарьковенко А. Руднев. Д

2. Зависимые и предшествующие задачи

   Предшествующая:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Данная задача основывается на использовании визиторов и решается путем нахождения необходимых условий для преобразований, а именно значение у одного из аргументы 0 и операции умножения. И замене данного выражения на 0;

До:
b = 4;
a = b * 0;
После:
b = 4;
a = 0;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения типа “a = b* 0” и “a = 0 * b” константу 0. Часть кода, отвечающий за такую замену приведена ниже:

if (binop is BinExprNode bi)
{
    if (bi.Left is ExprNode && bi.Right is IntNumNode 
        && ((bi.Right as IntNumNode).Num == 0)
        && bi.OpType == BinOpType.Prod)
    {
      	bi.Right.Visit(this);
        ReplaceExpr(bi, new IntNumNode(0));
        IsChanged = true;
    }
    else 
    { 
      	IsChanged = false;
    }
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью MultiplyOnZero- оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Пример:

[Test]
public void Test2()
{
    var text = 
@"{
c = 4;
b = 5;
a = b*0 + 0*c;
}";
      
/* построение синтаксического дерева */

    var Opt = new MultiplyOnZero();
    parser.root.Visit(Opt);
            
    var Opt2 =  new MultiplyOnZero2();
    parser.root.Visit(Opt2);

    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);

    var TAC = GenerateTAC(prettyPrinter.FormattedProgram);

    var expected = new List<string>()
    {
        "c = 4",
        "b = 5",
        "#t0 = 0 + 0",
        "a = #t0"
    };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гарьковенко А. Руднев. Д.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

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

До:
b = 4;
a = b - b;
После:
b = 4;
a = 0;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения типа “ a = b-b” константу 0. Часть кода, отвечающий за такую замену приведена ниже:

if (binop is BinExprNode bi)
{
    if (bi.Left is IdNode && bi.Right is IdNode  
        && ((bi.Left as IdNode).Name == (bi.Right as IdNode).Name)
        && bi.OpType == BinOpType.Minus)
    {
        ReplaceExpr(bi, new IntNumNode(0));
        IsChanged = true;
    }
    else {
        IsChanged = false;
    }
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью MinusSelf - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом.

[Test]
public void Test1()
{
    var Text =
@"{
b = 5;
a = b-b;
}
";

/* построение синтаксического дерева */

    var Opt = new MinusSelf();
    parser.root.Visit(Opt);

    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);
    var TAC = GenerateTAC(prettyPrinter.FormattedProgram);
    var expected = new List<string>()
        {
            "b = 5",
            "a = 0"
        };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гуртовой А. И., Остапенко М. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Реализация данной задачи представляет собой замену узла условного оператора сравнения чисел булевой константой с помощью визитора.

4. Теория

Данная задача основывается на использовании визиторов и решается путем нахождения необходимых условий для преобразований, а именно значение у одного из аргументы 0 и операции умножения. И замене данного выражения на 0;

До:
b = 4;
a = 2 < 3;
После:
b = 4;
a = true;

5. Реализация

В реализации данной задачи использовался отдельный класс-визитор, созданный специально для этой задачи. При обходе дерева, выражения типа “2 < 3” заменяются на узел, содержащий булеву константу. Ниже приведен код, отвечающий за реализацию оптимизации:

if (number1 != null && number2 != null)
{
    BoolValNode newExpr = null;
    if (binExpr.OpType == BinOpType.Less)
    {
        newExpr = new BoolValNode(number1 < number2);
        ReplaceExpr(binExpr, newExpr);
    }
    if (binExpr.OpType == BinOpType.Greater)
    {
        newExpr = new BoolValNode(number1 > number2);
        ReplaceExpr(binExpr, newExpr);
    }
    if (newExpr != null)
    {
        isChanged = true;
        base.Visit(newExpr);
    }
}
if (!isChanged)
{
    base.Visit(binExpr);
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, затем оно оптимизируется с помощью NumberEqualityVisitor - оптимизирующий визитор, узел оптимизированного дерева затем сравнивается с предполагаемым ответом. Пример:

[TestCase("a = 2 < 3;", "a = true;")]
[TestCase("a = 5 < 7;", "a = true;")]
public void OneLineTests(string line, string expected)
{
    var parser = GenerateTree(@"{" + $"\n{line}\n" + @"}");
    var expectedTree = GenerateTree(@"{" + $"\n{expected}\n" + @"}");
    var a = new NumberEqualityVisitor();
    a.Visit(parser.root);
    var first = (parser.root.StList[0] as AssignNode).Expr as BoolValNode;
    var second = (expectedTree.root.StList[0] as AssignNode).Expr as BoolValNode;
    Assert.AreEqual(first.Val, second.Val);
}

1. Команда, реализующая задачу Чухин А. И., Агафонцев Р. Г.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Данная задача основывается на использовании визиторов и решается путем замены в узле условного оператора оператора равенства двух чисел на булеву константу false. Помимо указанного 2 == 4, были учтены все остальные варианты операторы сравнения двух чисел (>=, <=, !=, >, <).

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

До:
b = 4;
a = 2 == 4;
После:
b = 4;
a = false;

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения, приведенного выше типа, заменялись на новый узел, содержащий булево значение. Фрагмент кода, класса, отвечающего за данную задачу приведен ниже:

public class NumberEqualityVisitor : ChangeVisitor
{
    public override void Visit(BinExprNode binExpr)
    {
        double? number1 = null, number2 = null;
        bool isChanged = false;
        if (binExpr.Left is IntNumNode || binExpr.Left is FloatNumNode)
        {
            if (binExpr.Left is IntNumNode i)
                number1 = i.Num;
            if (binExpr.Left is FloatNumNode f)
            number1 = f.Num;
        }
        if (binExpr.Right is IntNumNode || binExpr.Right is FloatNumNode)
        {
            if (binExpr.Right is IntNumNode i)
                number2 = i.Num;
            if (binExpr.Right is FloatNumNode f)
                number2 = f.Num;
        }
        if (number1 != null && number2 != null)
        {
            BoolValNode newExpr = null;
            if (binExpr.OpType == BinOpType.Equal)
            {
                newExpr = new BoolValNode(number1 == number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (binExpr.OpType == BinOpType.NotEqual)
            {
                newExpr = new BoolValNode(number1 != number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (binExpr.OpType == BinOpType.Less)
            {
                newExpr = new BoolValNode(number1 < number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (binExpr.OpType == BinOpType.Greater)
            {
                newExpr = new BoolValNode(number1 > number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (binExpr.OpType == BinOpType.LessOrEqual)
            {
                newExpr = new BoolValNode(number1 <= number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (binExpr.OpType == BinOpType.GreaterOrEqual)
            {
                newExpr = new BoolValNode(number1 >= number2);
                ReplaceExpr(binExpr, newExpr);
            }
            if (newExpr != null)
            {
                isChanged = true;
                base.Visit(newExpr);
            }
        }   
        if (!isChanged)
        {
            base.Visit(binExpr);
        }
    }
}

6. Интеграция в общий проект

Класс наследуются от общего для всех подобных оптимизаций предка ChangeVisitor.

7. Тесты

1. Команда, реализующая задачу Погорелов А. А., Домбровская А. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Данная задача основывается на использовании визиторов и решается путем замены в узле условного оператора оператора равенства на булеву константу true. Помимо указанных a == a и a >= a, был также учтен вариант a <= a.

До:
if a == a
{
	st1;
}
После:
if true
{
	st1;
}

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения типа “a==a”, “a>=a” и “a<=a” заменялись на новый узел, инкапсулирующий константу true. Часть кода, отвечающий за такую замену приведена ниже:

if (node.Left is IdNode leftIdNode 
    && node.Right is IdNode rightIdNode
    && leftIdNode.Name.Equals(rightIdNode.Name)
    && (node.OpType == BinOpType.Equal
    || node.OpType == BinOpType.LessOrEqual
    || node.OpType == BinOpType.GreaterOrEqual))
{
    ReplaceExpr(node, new BoolValNode(true));
    IsChanged = true;
}
else
{
    IsChanged = false;
    base.Visit(node);
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью TrueConditionOptVisitor - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Пример:

[Test]
public void SimpleIf()
{
    var Text =
@"
{
  if a == a
  {
    b = a;
  }
}
";
    Scanner scanner = new Scanner();
    scanner.SetSource(Text, 0);
    Parser parser = new Parser(scanner);
    parser.Parse();
    var parentFiller = new FillParentsVisitor();
    parser.root.Visit(parentFiller);

    var trueOpt = new TrueConditionOptVisitor();
    parser.root.Visit(trueOpt);
    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);
    var TAC = GenerateTAC(prettyPrinter.FormattedProgram);

    var expected = new List<string>()
    {
        "if True goto #L0",
        "goto #L1",
        "#L0",
        "b = a",
        "#L1"
    };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Османян В. А., Маслова О. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Данная задача основывается на использовании визиторов и решается путем замены в узле условного оператора больше на булеву константу false. Помимо указанных a > a и a != a, был также учтен вариант a < a.

До:
if a > a
{
    st2;
}
После:
if (false)
{
    st2;
} 
До: 
if a != a
{
    st2;
} 
После:
if (false)
{
    st2;
}

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения типа “a > a”, “a != a” и “a < a” заменялись на новый узел, инкапсулирующий константу false. Часть кода, отвечающий за такую замену приведена ниже:

if (node.Left is IdNode leftIdNode 
        && node.Right is IdNode rightIdNode
        && leftIdNode.Name.Equals(rightIdNode.Name)
        && (node.OpType == BinOpType.Greater
        || node.OpType == BinOpType.Less
        || node.OpType == BinOpType.NotEqual))
{
    ReplaceExpr(node, new BoolValNode(false));
    IsChanged = true;
} 
else
{
    IsChanged = false;
    base.Visit(node);
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью SelfNotEqualTest - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Пример:

[Test]
public void SelfNotEqualTest()
    {
        var parser = GenerateTree(
@"{
if (a!=a)
{
a = 5;
}
else
{
b = 1;
}
}");
    var expectedTree = GenerateTree(
@"{
if (false)
{
a = 5;
}
else
{
b = 1;
}
}");
    var a = new FindFalseVisitor();
    a.Visit(parser.root);
    var first = (parser.root.StList[0] as AssignNode);
    var second = (expectedTree.root.StList[0] as AssignNode);
    Assert.AreEqual(first, second);
}

1. Команда, реализующая задачу Чубинидзе Н. Р., Романченко Р. Д.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Данная задача основывается на использовании визиторов и решается путем замены узла оператора присваивания на null.

До:
a = a
После:
null

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, выражения типа “a = a” заменялись на пустой узел, который затем удалялся из дерева. Часть кода, отвечающий за такую замену приведена ниже:

if (n is AssignNode a)
{
    if (a.Expr is IdNode idNode && idNode.Name == a.Id.Name)
    {
      	ReplaceStatement(a, new EmptyStatement());
    }
}
else if (n is BlockNode bl)
    {
        bl.StList = bl.StList.Where(x => !(x is EmptyStatement)).ToList();
    }

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью SameAssignmentOptVisitor- оптимизирующий визитор, после чего из кода удаляются пустые выражения RemoveEmptyStatementVisitor. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Тест с последовательным применением визиторов представлен ниже:

[Test]
public void SimpleTest1()
{
    var Text =
@"
{
  a = a;
}
";
// . . . заполнение предков дерева

    var optimizators = new List<ChangeVisitor>
    {
        new SameAssignmentOptVisitor(),
        new RemoveEmptyStatementVisitor()
    };

    int countOptimization = 0;
    while (countOptimization < optimizators.Count)
    {
        parser.root.Visit(optimizators[countOptimization]);
        if (optimizators[countOptimization].IsChanged)
        {
            optimizators[countOptimization].IsChanged = false;
            countOptimization = 0;
        }
        else countOptimization++;
    }
// . . . генерация TAC-кода
    var expected = new List<string>();
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Погорелов А. А., Домбровская А. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

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

До:
if true
{
	st1;
}
После:
st1;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, булевы константы “true” заменялись на узел, соответствующий выражению в первой ветке условного оператора. Часть кода, отвечающий за такую замену приведена ниже:

if (node.Condition is BoolValNode bv && bv.Val)
{
    Visit(node.Stat);
    ReplaceStatement(node, node.Stat);
    IsChanged = true;
}
else
{
    IsChanged = false;
    base.Visit(node);
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью TrueIfOptVisitor - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Пример:

[Test]
public void SimpleIf()
{
    var Text =
@"
{
  if true
  {
    b = a;
  }
}
";
    Scanner scanner = new Scanner();
    scanner.SetSource(Text, 0);
    Parser parser = new Parser(scanner);
    parser.Parse();
    var parentFiller = new FillParentsVisitor();
    parser.root.Visit(parentFiller);

    var trueIfOpt = new TrueIfOptVisitor();
    parser.root.Visit(trueIfOpt);

    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);

    var TACGenerator = new TACGenerationVisitor();
    parser.root.Visit(TACGenerator);
    var TAC = TACGenerator.TAC;

    var expected = new List<string>()
    {
        "b = a"
    };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

Примечание: Данная задача также реализована командой Чухин А. И., Агафонцев Р. Г. Однако интегрировано в общий конвейер было решение, описанное выше. Тесты и реализация данной команды представлены в проекте.

1. Команда, реализующая задачу Османям В. А., Маслова О. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

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

До:
if (false)
{
    st1;
}
else
{
    st2;
}
После:
st2;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

При реализации использовался паттерн “Визитор”. Оптимизация была вынесена в отдельный класс-визитор и при обходе синтаксического дерева данным визитором, булевы константы “false” заменялись на узел, соответствующий выражению в первой ветке условного оператора. Часть кода, отвечающий за такую замену приведена ниже:

if (node.Condition is BoolValNode bv && !bv.Val)
{
    if (node.ElseStat != null)
    {
        Visit(node.ElseStat);
        ReplaceStatement(node, node.ElseStat);
    } 
    else
    {
        ReplaceStatement(node, new EmptyStatement());
    }
    IsChanged = true;
}
else
{
    IsChanged = false;
    base.Visit(node);
}

public override void PostVisit(Node n)
{
    if (n is BlockNode bl)
    {
        bl.StList = bl.StList.Where(x => !(x is EmptyStatement)).ToList();
    }
}

---

6. **Интеграция в общий проект**

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

7. **Тесты**

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью SelfNotEqualTest - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом.
Пример

---
```Csharp
[Test]
public void ifFalseTest()
{
    var parser = GenerateTree(
@"{
if (false)
{
a = 5;
}
else
{
b = 1;
}
}");
    var expectedTree = GenerateTree(
@"
{
{
b = 1;
};
}");
    var a = new IfFalseVisitor();
    a.Visit(parser.root);
    var first = (parser.root.StList[0] as AssignNode);
    var second = (expectedTree.root.StList[0] as AssignNode);
    Assert.AreEqual(first, second);
    }
}

1. Команда, реализующая задачу Чубинидзе Н. Р., Романченко Р. Д.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

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

До:
if true
{
	null;
} 
else 
{
	null;
}
После:
	null;

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Один визитор - одна группа действий, позволяющая выполнять простейшую оптимизацию, над узлами дерева. Контекст в данной задаче не важен.

5. Реализация

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

if (n is IfNode ifN)
{
if ((ifN.Stat.StList.Count == 0 && ifN.ElseStat == null) 
    || (ifN.Stat.StList.Count == 0 
    && ifN.ElseStat.StList.Count == 0))
{
    ReplaceStatement(ifN, new EmptyStatement());
}
    if (ifN.ElseStat != null && ifN.ElseStat.StList.Count == 0)
    {
        ReplaceStatement(ifN, new IfNode(ifN.Condition, ifN.Stat));
    }
}
else if (n is BlockNode bl)
{
    var prevLength = bl.StList.Count;
    bl.StList = bl.StList.Where(x => !(x is EmptyStatement)).ToList();
    IsChanged = prevLength != bl.StList.Count;
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью NullIfElseOptVisitor - оптимизирующий визитор, после чего из кода удаляются пустые выражения RemoveEmptyStatementVisitor. В данном тесте потребовалось использовать также SameAssignmentOptVisitor для получения пустого оператора. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом. Тест с последовательным применением визиторов представлен ниже Пример:

[Test]
public void SimpleTest1()
{
    var Text =
@"
{
  if (a > b) 
  {
    a = a;
  }
}
";
		
// . . . заполнение предков дерева

    var optimizators = new List<ChangeVisitor>
    {
        new SameAssignmentOptVisitor(),
        new NullIfElseOptVisitor(),
        new RemoveEmptyStatementVisitor()
    };

    int countOptimization = 0;
    while (countOptimization < optimizators.Count)
    {
        parser.root.Visit(optimizators[countOptimization]);
        if (optimizators[countOptimization].IsChanged)
        {
            optimizators[countOptimization].IsChanged = false;
            countOptimization = 0;
        }
            else countOptimization++;
    }
// . . . генерация TAC-кода
    var expected = new List<string>();
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гуртовой А. И., Остапенко М. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Построение синтаксического дерева

  Зависимые: -

3. Аннотация

Реализация данной задачи представляет собой замену узла оператора цикла while на пустой узел с помощью визитора.

До:
while false
{
	a = 3;
} 
После:
null;

4. Теория

Визитор – группа действий, выполняющая простейшую оптимизацию над узлами AST-дерева.

5. Реализация

В реализации данной задачи использовался отдельный класс-визитор, созданный специально для этой задачи. При обходе дерева циклы while типа “while (false) st” заменяются на узел, представляющий собой пустой узел, содержащий в себе “null”. Ниже приведен код, отвечающий за реализацию оптимизации:

public class EmptyStatement : StatementNode
{
    public EmptyStatement() { }
    public override void Visit(Visitor v)
    {

    }

}

. . .

if (node.Condition is BoolValNode bv && bv.Val == false)
{
    ReplaceStatement(node, new EmptyStatement());
}
else
{
    base.Visit(node);
}

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке строится синтаксическое дерево, заполняются все предки, затем оно оптимизируется с помощью WhileFalseVisitor - оптимизирующий визитор. По оптимизированному дереву генерируется TAC-код, который затем сравнивается с предполагаемым ответом.

[Test]
public void Test1()
{
    var Text =
@"
{
a = 3;
while (false)
    {
    b = a;
    }
}
";
    Scanner scanner = new Scanner();
    scanner.SetSource(Text, 0);
    Parser parser = new Parser(scanner);
    parser.Parse();
    var parentFiller = new FillParentsVisitor();
    parser.root.Visit(parentFiller);    
    var whileFalse = new WhileFalseVisitor();   
    parser.root.Visit(whileFalse);
    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);   
    var TACGenerator = new TACGenerationVisitor();
    parser.root.Visit(TACGenerator);
    var TAC = TACGenerator.TAC;
    
    var expected = new List<string>()
    {
        "a = 3"
    };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гарьковенко А., Руднев. Д

2. Зависимые и предшествующие задачи

   Предшествующие:

• генерация трехадресного кода;

• все оптимизации по дереву;

• разбиение на базовые блоки.

  Зависимые: -

3. Аннотация

Решение данной задачи отвечает за реализацию общего конвейера оптимизаций.Решение данной задачи отвечает за реализацию общего конвейера оптимизаций.Решение данной задачи отвечает за реализацию общего конвейера оптимизаций.

4. Теория

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

5. Реализация

Были реализованы два класса, один Общий для трехадресных оптимизаций, и один для оптимизаций по дереву, они оба содержат списки всех, возможных оптимизаций. Ниже представлен код, отвечающий за генерацию списка оптимизаций по синтаксическому дереву:

public static List<ChangeVisitor> ChangeVisitorsOptimization = new List<ChangeVisitor>
{
    new SameAssignmentOptVisitor(),
    new NumberEqualityVisitor(),
    new MinusSelf(),
    new FindFalseVisitor(),
    new WhileFalseVisitor(),
    new MultiplyOnZero(),
    new MultiplyOnZero2(),
    new TrueConditionOptVisitor(),
    new TrueIfOptVisitor(),
    new NullIfElseOptVisitor(),
    new RemoveEmptyStatementVisitor(),
    new ConstantFoldingVisitor(),
    new IfFalseVisitor(),
    new AlgebraicIdentityProdDiv1Visitor(),
    new AlgebraicIdentitySum0Visitor()
};

Для организации работы все оптимизаторов была написана функция, которая последовательно проверяет, отработал ли какой-нибудь из оптимизаторов, если да, то итеративный процесс начинается заново:

public static void Optimization(Parser parser)
{
    int countOptimization = 0;
    while (countOptimization < ChangeVisitorsOptimization.Count)
    {
      	parser.root.Visit(ChangeVisitorsOptimization[countOptimization]);
        if (ChangeVisitorsOptimization[countOptimization].IsChanged)
        {
            ChangeVisitorsOptimization[countOptimization].IsChanged = false;
            countOptimization = 0;
        }
        else countOptimization++;
    }
}

Аналогичный конвейер реализован для оптимизаций по TAC-коду.

6. Интеграция в общий проект

Для интеграции со всеми оптимизациями, были реализован список оптимизаций

7. Тесты

Тестирование проходит следующим образом: сначала по заданной программе генерируется TAC-код, затем к нему применяется общий конвейер оптимизаций, который запускается командой Optimization(). Затем оптимизированный TAC-код сравнивается с предполагаемым ответом. Пример:

[Test]
public void WhileFalseOptimization()
{
    var Text =
@"
{
x = 13;
b = 14;
while (7 - 7 == 3 - 1)
  {
    x = x * (a - a);
    b = b;
  }
}
";
            
/* построение синтаксического дерева */

    AllVisitorsOptimization.Optimization(parser);

    var prettyPrinter = new PrettyPrinterVisitor();
    parser.root.Visit(prettyPrinter);

    var TACGenerator = new TACGenerationVisitor();
    parser.root.Visit(TACGenerator);
    var TAC = TACGenerator.TAC;

    var expected = new List<string>()
        {
            "x = 13",
            "b = 14"
        };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Погорелов А. А., Домбровская А. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• построение AST дерева.

  Зависимые:

• учет алгебраических тождеств;

• живые и мертвые переменные, удаление мертвого кода;

• протяжка констант;

• протяжка копий;

• оптимизация общих подвыражений;

• устранение переходов через переходы;

• свертка констант;

• создание структуры ББл.

3. Аннотация

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

4. Теория

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

x = y op z;
x = y;
x = op y;
if x goto L
goto L.

где op - любая алгебраическая операция, L - метка. Представление в виде пятерок:

5. Реализация

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

var genCond = GenerateTACExpr(node.Condition);
var label1 = GenerateTempLabel();
var label2 = GenerateTempLabel();
AddInstruction("if goto", genCond, label1, "");
if (node.ElseStat != null)
node.ElseStat.Visit(this);
AddInstruction("goto", label2, "", "");
AddInstruction("", "", "", "", label1);
node.Stat.Visit(this);
AddInstruction("", "", "", "", label2);

Однако, при обходе узла выражения, использовалась специальная рекурсивная функция GenerateTACExpr. Это сделано для того, чтобы эффективно и просто генерировать очередную временную переменную, если в правой части выражения содержиться более 2 аргументов. Часть кода этой функции, отвечающую за генерацию трехадресных инструкций для бинарных выражений, можно увидеть ниже:

var bin = ex as BinExprNode;
string tmp1 = GenerateTACExpr(bin.Left);
string tmp2 = GenerateTACExpr(bin.Right);
string tmp = GenerateTempName();
AddInstruction(bin.OpType.ToFriendlyString(), tmp1, tmp2, tmp);
return tmp;

6. Интеграция в общий проект

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

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке генерируется TAC-код, затем полученный код сравнивается с предполагаемым ответом. Тестами покрыты все возможные в нашем языке операторы. Пример:

[Test]
public void SimpleGeneration()
{
    var TAC = GenerateTAC(
@"
{
  int x;
  x = 14;
  y = 2 * (a + b) - c;
  x = x + x;
}
");
    var expected = new List<string>()
    {
        "x = 14",
        "#t0 = a + b",
        "#t1 = 2 * #t0",
        "#t2 = #t1 - c",
        "y = #t2",
        "#t3 = x + x",
        "x = #t3"
    };
    var actual = TAC.Instructions.Select(instruction => instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Османян В., Маслова О.
2. Зависимые и предшествующие задачи

Предшествующие

• Генерация трехадресного кода для всех конструкций

Зависимые

• Построение CFG (Control Flow Graph)
• все итерационные алгоритмы.

3. Аннотация В этом задаче вводится представление промежуточного кода в виде графа, полезное при рассмотрении генерации кода (даже если алгоритм генерации кода не строит граф явным образом).

4. Теория

Представление строится следующим образом:

1 ) Промежуточный код разделяется на базовые блоки (basic blocks), представ- ляющие собой максимальные последовательности следующих друг за дру- том трехадресных команд, обладающие приведенными ниже свойствами:

а) поток управления может входить в базовый блок только через первую
команду блока, т.е. переходы в середину блока отсутствуют;

б) управление покидает блок без останова или ветвления, за исключени-
ем, возможно, в последней команде блока.

2 ) Базовые блоки становятся узлами графа потока (CFG), ребра кото- рого указывают порядок следования блоков.

Данная оптимизация позволяет в дальнейшем рассматривать трансформации графов потоков, которые преобразуют исходный промежуточный код в “оптимизированный” про- межуточный код, позволяющий генерировать более качественный целевой код. “Оптимизированный” промежуточный код преврашается в машинный код с по- мощью методов генерации трехадресного кода (ThreeAddressCode.cs).

5. Реализация

Исходя из определений, приведенных в источнике Дж. Ульман, А. Ахо "Компиляторы: принципы, технологии и инструментарий", была реализована структура в виде классов, содержащих связь ББл и CFG:

public class BasicBlock
    {
        private static int index;

        private List<TACInstruction> instructions = new List<TACInstruction>();
        private List<BasicBlock> _Out = new List<BasicBlock>();
        private List<BasicBlock> _In = new List<BasicBlock>();

        public int Index { get; private set; }

        public List<TACInstruction> Instructions
        {
            get
            {
                return instructions;
            }

        }
        public List<BasicBlock> In
        {
            get
            {
                return _In;
            }
            set
            {
                _In = value;
            }

        }

        public List<BasicBlock> Out
        {
            get
            {
                return _Out;
            }
            set
            {
                _Out = value;
            }

        }
        public BasicBlock()
        {
            instructions = new List<TACInstruction>();
            _Out = new List<BasicBlock>();
            _In = new List<BasicBlock>();
            Index = index++;
        }

        public BasicBlock(List<TACInstruction> instr)
        {
            instructions = instr;
            _Out = new List<BasicBlock>();
            _In = new List<BasicBlock>();
            Index = index++;
        }

        public override int GetHashCode()
        {
            return Index;
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            var second = obj as BasicBlock;
            if (second == null)
            {
                return false;
            }
            return second.Index == Index;
        }

        public override string ToString()
        {
            var builder = new StringBuilder();
            foreach (var i in Instructions)
            {
                builder.Append(i.ToString().Trim());
                builder.Append('\n');
            }
            return builder.ToString();
        }

        /// <summary>
        /// Обнуляет внутренный статический счетчик индексов
        /// </summary>
        public static void clearIndexCounter()
        {
            index = 0;
        }
    }

6. Интеграция в общий проект

Команада, реализовавшая алгоритм разбиения программы на ББл, воспользовалась алгоритмом определения структуры ББл. Данная задача является опорной, поскольку от её качества реализации зависел в целом результат выполнения заданий остальными командами.

7. Тесты

Также необходимая архитектура тестов была имплементирована и задокументирована:

public class TACTestsBase
    {
        protected ThreeAddressCode GenerateTAC(string sourceCode)
        {
            Scanner scanner = new Scanner();
            scanner.SetSource(sourceCode, 0);

            Parser parser = new Parser(scanner);
            parser.Parse();

            var parentFiller = new FillParentsVisitor();
            parser.root.Visit(parentFiller);

            var TACGenerator = new TACGenerationVisitor();
            parser.root.Visit(TACGenerator);
            return TACGenerator.TAC;
            /*
            var TACBlocks = new TACBaseBlocks(TACGenerator.Instructions);
            TACBlocks.GenBaseBlocks();
            var cfg = new ControlFlowGraph(TACBlocks.blocks);
            */
        }
    }

1. Команда, реализующая задачу Чубинидзе Н. Р., Романченко Р. Д.

2. Зависимые и предшествующие задачи

   Предшествующие:

• генерация трехадресного кода;

• создание структуры ББл.

  Зависимые:

• построение CFG;

• все итерационные алгоритмы.

3. Аннотация

Разбиение на базовые блоки лежит в основе построения CFG и всех итерационных алгоритмов.

4. Теория

Базовый блок - это максимальная последовательность команд трехадресного кода, удовлетворяющая следующим условиям:

• поток управления может входить в ББл только через первую команду;
• управление покидает ББл без останова или ветвления, за исключением, возможно, последней команды. Базовый блок также может быть определен как блок от лидера до лидера, где команда-лидер это:
• первая команда;
• любая команда, на которую есть переход;
• любая команда, непосредственно следующая за переходом.

5. Реализация

Реализация данной задачи базируется структуре ББл, определенной другой командой. Генерация блоков проходит в соответствии с определением, заявленным выше. Сначала в список блоков добавляется первая команда, затем инструкции, на которые есть переход:

if (instructions[i - 1].Operation.Contains("goto"))
{
    var label = "";
    if (instructions[i - 1].Operation.Equals("goto"))
        label = instructions[i - 1].Argument1;
    else if (instructions[i - 1].Operation.Equals("if goto"))
        label = instructions[i - 1].Argument2;
    for (int j = 1; j < instructions.Count; ++j)
    {
      	if (instructions[j].HasLabel && instructions[j].Label.Equals(label))
      	list.Add(j);
    }
list.Add(i);
}

А затем операции, следующие сразу за переходом:

if (instructions[instructions.Count - 1].Operation.Equals("goto"))
    for (int j = 1; j < instructions.Count; ++j)
    {
        if (instructions[j].HasLabel && instructions[j]
            .Label.Equals(instructions[instructions.Count - 1].Argument1))
      	    list.Add(j);
 }

Наконец, объединение базовых блоков происходит следующим образом:

foreach (var block in blocks)
{
    foreach (var instr in block.Instructions)
    {
        merging.Add(instr);
    }
}

6. Интеграция в общий проект

Генерация трехадресного кода заложила основу для CFG и итерационных алгоритмов. При последовательном обходе инструкций TAC, создается экземпляр специального класса TACBaseBlocks, позволяющий получать доступ к отдельным инструкциям и базовым блокам.

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке генерируется TAC-код, затем на основе полученного списка инструкций генерируются базовые блоки. В конце результат разбиения на блоки сравнивается с предполагаемым ответом. Пример:

[Test]
public void SimpleOneBlockTest1()
{
    var TAC = GenerateTAC(
@"
{
  int x;
  x = 14;
  y = 2 * (a + b) - c;
  x = x + x;
}
");
    var blocks = new TACBaseBlocks(TAC.Instructions);
    blocks.GenBaseBlocks();
    Assert.AreEqual(blocks.blocks.Count, 1);

    var expected = new List<List<string>>()
    {
        new List<string>() 
        {
            "x = 14",
            "#t0 = a + b",
            "#t1 = 2 * #t0",
            "#t2 = #t1 - c",
            "y = #t2",
            "#t3 = x + x",
            "x = #t3"
        }
    };
    var actual = blocks.blocks
        .Select(block => block.Instructions
            .Select(instr => instr.ToString().Trim())).ToList();
    Assert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Гуртовой А. И., Остапенко М. В.

2. Зависимые и предшествующие задачи

   Предшествующие: - Зависимые: -

3. Аннотация

Архитектура системы тестирования оптимизаций позволяет выявить недостатки оптимизаций и проблемы совместимости этих оптимизаций. В качестве главного инструмента тестирования было выбрано расширение для Visual Studio Unit Test - NUnit3TestAdapter.

4. Теория

-

5. Реализация

Для того, чтобы получить доступ к возможностям NUnit3TestAdapter, необходимо было сначала добавить его к пакетам NuGet проекта. Затем в тестовых файлах каждой оптимизации нужно было подключить NUnit.Framework. После этого каждый класс для тестирования оптимизаций был помечен как [TestFixture]. Все тестирующие функции для каждого отдельного случая помечаются как [Test]. Ниже приведен пример содержимого тестового файла:

[TestFixture]
class OptimizerNameTests: TestsBase
{
    [Test]
    public void Test1() { /* содержимое теста */ }
    [Test]
    public void Test2() { /* содержимое теста */ }
/* другие тесты */

В конце каждой тестовой функции происходит сравнение результатов и в случае их несовпадения, данный тест помечается, как провалившийся во вкладке TestExplorer. Иначе, тест помечается, как успешно пройденный. Задача всех групп сделать так, чтобы все случаи были покрыты тестами и все тесты были помечены, как успешно пройденные.

6. Интеграция в общий проект

Был добавлен отдельный проект для тестов и подключен фреймворк NUnit.

7. Тесты

-

1. Команда, реализующая задачу Манукян Г. А.

2. Зависимые и предшествующие задачи

   Предшествующая:

• Построение графа потока управления (CFG – Control Flow Graph)

• Вычисление передаточной функции для достигающих определений

• Создание структуры базовых блоков, графа CFG

• Разбиение на ББл (от лидера до лидера) + слияние ББл в единый список

  Зависимые:

• Итерационный алгоритм для достигающих определений, ~в обобщенной структуре

3. Аннотация

Цель оптимизации – в каждой инструкции 1,2,3...n базового блока вычислить свою передаточную функцию, объединить их в композицию, потом проверить вычисление общей передаточной функции. С точки зрения обхода CFG, выделяют прямой и обратный обходы. В каждой отдельной ситуации значение передаточной функции композиции функции вычисляется единообразно.

4. Теория

Передаточная функция f_B блока B по определению равна композиции передаточных функций его инструкций I_1, ..., I_n:

Пример: d: u = v + w f_d(X) = gend_d ∪ (X − kill_d) , где gen_d = {d}, kill_d = {} gen_B – мн-во определений, генерируемых и не переопределённых базовым блоком B. kill_B – мн-во остальных определений переменных, определяемых в опр-ях gen_B, в других ББл.

5. Реализация

Так как речь идет о передаточной функции инструкции определенного базового блока, естественно сформировать таблицы для множеств из определения функции:

private ILookup<string, TACInstruction> def_b;
private ILookup<BasicBlock, TACInstruction> gen_b;
private ILookup<BasicBlock, TACInstruction> kill_b;

Теперь в два прохода по блокам O(Len_B) заполняем таблицы, то есть для каждой инструкции, в которой есть оператор „=” мы добавляем ее во множество defs:

List<TACInstruction> defs = new List<TACInstruction>();
    foreach (var block in blocks)
        foreach (var instruction in block.Instructions)
            if (instruction.Operation == "=")
                defs.Add(instruction);
    def_b = defs.ToLookup(x => x.Result, x => x);

Множества gen, kill получены, как и следует из определения, следующим образом:

1. Каждое сгенерированное блоком B определение переменной (“=”), и не переопределенное им же;
2. Если в таблице defs встретилось определение, то оно автоматически добавляется в kill, искл. gen:

List<(BasicBlock, TACInstruction)> gen = new List<ValueTuple<BasicBlock, TACInstruction>>();
List<(BasicBlock, TACInstruction)> kill = new List<ValueTuple<BasicBlock, TACInstruction>>();
foreach (var block in blocks)
{
  var flag = new HashSet<string>();
  foreach (var instruction in block.Instructions.Reverse<TACInstruction>())
  { 
    if (!flag.Contains(instruction.Result) && instruction.Operation == "=")
    {
      gen.Add((block, instruction));
      flag.Add(instruction.Result);
    }
    foreach (var exclude_def in def_b[instruction.Result].Where(x => x != instruction))
      kill.Add((block, exclude_def));
    }
}
gen_b = gen.ToLookup(x => x.Item1, x => x.Item2);
kill = kill.Distinct().ToList();
kill_b = kill.ToLookup(x => x.Item1, x => x.Item2);

Для дополнительной функциональности, добавлены функции возвращения всех трех множеств, а также применения – ApplyTransferFunc к списку IEnumerable.

6. Интеграция в общий проект

В классе, отведенном под граф потока управления добавлена следующая функциональность: список всех потомков и список всех предков текущего базового блока (ББЛ). В задаче «Итерационный алгоритм в обобщенной структуре» данная функциональность необходима» В задаче на обобщенный итерационный алгоритм, необходимый для написания итерационного алгоритма распространения констант, использует данную функцию, а также модифицированный CFG. Таким образом, передаточная функция для достигающих определений композицией передаточных функций команд полностью интегрирована и участвует в реализации итерационного алгоритма.

7. Тесты

Унаследовавшись от базового класса IterAlgoGeneric – обобщенного базового алгоритма (см. задание 4), применена передаточная функция для дост. опр. композ. пер. ф-ций команд: Класс-наследник – итерационный алгоритм:

public class SampleClassIterAlgoForTransferFunc :
IterAlgoGeneric<IEnumerable<TACInstruction>>
{
/// <inheritdoc/>
    public override Func<IEnumerable<TACInstruction>, IEnumerable<TACInstruction>,      IEnumerable<TACInstruction>> CollectingOperator => (a, b) => a.Union(b);

/// <inheritdoc/>
        public override Func<IEnumerable<TACInstruction>, IEnumerable<TACInstruction>, bool> Compare
            => (a, b) => !a.Except(b).Any() && !b.Except(a).Any();

/// <inheritdoc/>
        public override IEnumerable<TACInstruction> Init { get => Enumerable.Empty<TACInstruction>(); protected set { } }

/// <inheritdoc/>
        public override Func<BasicBlock, IEnumerable<TACInstruction>, IEnumerable<TACInstruction>> TransferFunction { get; protected set; }

        public override InOutData<IEnumerable<TACInstruction>> Execute(
        ControlFlowGraph graph)
        {
            TransferFunction = new ReachingTransferFunc(graph).Transfer;
            return base.Execute(graph);
        }

        public override void Run()
        {
            this.Execute(Cfg);
        }
}

Тесты – среднее время компиляции – 3 мс, всего 6 тестов, из них проходят – 6.

using InOutInfo = InOutData<IEnumerable<TACInstruction>>;
[TestFixture]
class TransferFuncForIterativeAlgorithm : CFGTestsBase
{
    protected (List<BasicBlock> basicBlocks, InOutInfo inOutInfo) GenGraphAndGetInOutInfo(string program)
    {
        var TAC = GenerateTAC(program);
        var TACBlocks = new TACBaseBlocks(TAC.Instructions);
        var cfg = new ControlFlowGraph(TACBlocks.blocks);
        var inOutInfo = new SampleClassIterAlgoForTransferFunc().Execute(cfg);
        return (TACBlocks.blocks, inOutInfo);
    }

    [Test]
    public void TestMultipleIfStatements()
    {
        (var blocks, var inOutInfo) = GenGraphAndGetInOutInfo(
@"
{
int a, b;
a = 5;
if a > 0
{
a = 0;
}
else
{
a = 1;
}
b = a;
}
");
    Assert.AreEqual(6, inOutInfo.Count);

    var falseBranch = blocks[1].Instructions.Take(1);
    var trueBranch = blocks[2].Instructions.Take(1);
    var lastBlock = blocks[3].Instructions.Skip(1);
    CollectionAssert.AreEquivalent(falseBranch.Concat(trueBranch), inOutInfo[blocks[3]].In);
    CollectionAssert.AreEquivalent(falseBranch.Concat(trueBranch).Concat(lastBlock),                                        inOutInfo[blocks[3]].Out);
        }

    [Test]
    public void BasicTest()
    {
        (var blocks, var inOutInfo) = GenGraphAndGetInOutInfo(
@"
{
int one;
one = 1;
}
");

// only one basic block + entry and exit
    Assert.AreEqual(3, inOutInfo.Count);

    Assert.AreEqual(0, inOutInfo[blocks[0]].In.Count());
    Assert.AreEqual(1, inOutInfo[blocks[0]].Out.Count());
    Assert.AreEqual(blocks[0].Instructions, inOutInfo[blocks[0]].Out);
}

После построения трехадресного кода и разбиения его на базовые блоки появлется задача оптимизации этих базовых блоков. Их можно разделить на локальные и глобальные оптимизации.

Локальная и глобальная оптимизации:

• Оптимизация в пределах базового блока – локальная
• Оптимизация между базовыми блоками – глобальная
• Локальная оптимизация существенно проще и позволяет во многих случаях существенно увеличить производительность малой ценой

Для оптимизаций базовых блоков необходимо решить следующие задачи:

1. Команда, реализующая задачу Гарьковенко А., Руднев. Д.

2. Зависимые и предшествующие задачи

   Предшествующие:

• генерация трехадресного кода;

  Зависимые: -

3. Аннотация

Данная задача основывается на анализе трехадресного кода внутри базового блока.Все переменные в конце блока объявляются живыми, и дальше начинается обход инструкций снизу вверх и переменная встречается слева от присваивания она объявляется мертвой. В конце мертвые переменные заменятся на блок “Empty”.

4. Теория

с1:	x = a;		// определение x (def)
. . .
с2:	y = x + z;	// использование x (use)

Если в промежутке между с1 и с2 x никак не переопределялось, то x является живой на этом участке кода, иначе - мертвой.

5. Реализация

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

var last = Instructions.Last();
newInscructions.Add(last);
assigmentInfo.Add(last.Result, false);
if (!int.TryParse(last.Argument1, out _) 
    && last.Argument1 != "True" 
    && last.Argument1 != "False")
        assigmentInfo[last.Argument1] = true;
if (!int.TryParse(last.Argument2, out _) 
    && last.Argument2 != "True" 
    && last.Argument2 != "False")
        assigmentInfo[last.Argument2] = true;

Далее запускается итерационный процесс по оставшимся инструкциям:

var inst = Instructions[i];
if (inst.Operation == "Empty")
{
    newInscructions.Add(inst);
    continue;
}
if (assigmentInfo.ContainsKey(inst.Result) && !assigmentInfo[inst.Result])
{
    newInscructions.Add(new TACInstruction("Empty", null, null, null, inst.Result));
    continue;
}
/* определение типа, как показано выше, для inst*/

6. Интеграция в общий проект

Процедура оптимизации с использованием всех оптимизаторов TAC, проходит в специальном классе, инкапсулирующем в себе конвейер оптимизаций. Для интеграции отдельного оптимизатора в общий проект, необходимо просто добавить экземпляр данного оптимизатора в коллекцию оптимизаторов конвейера.

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке генерируется TAC-код, затем к нему применяется оптимизатор DeadAliveOptimize, который запускается командой Run(). Затем оптимизированный TAC-код сравнивается с предполагаемым ответом. Пример:

[Test]
public void OneBlock1()
{
var TAC = GenerateTAC(
@"
{
  	  a = d;
  	  x = a;
  	  a = e;
  	  x = b;
  	  y = x + z;
}
");

    var optimizer = new DeadAliveOptimize(TAC);
    optimizer.Run();
    var actual = optimizer.Instructions;
    var expected = new List<TACInstruction>() 
      {
                new TACInstruction("Empty",null,null,null,"a"),
                new TACInstruction("Empty",null,null,null,"x"),
                new TACInstruction("=","e","","a",""),
                new TACInstruction("=","b","","x",""),
                new TACInstruction("+","x","z","#t0",""),
                new TACInstruction("=","#t0","","y",""),
      };
    Assert.AreEqual(actual, expected);
}

1. Команда, реализующая задачу Погорелов А. А., Домбровская А. В.

2. Зависимые и предшествующие задачи

   Предшествующие:

• генерация трехадресного кода;

• создание структуры ББл;

• разбиение на ББл.

  Зависимые: -

3. Аннотация

Учет алгебраических тождеств - это замена следующих выражений на переменные и константы:

x + 0 = x;
0 + x = x;
x - 0 = x;
x - x = 0;
x * 1 = x;
1 * x = x;
x * 0 = 0;
x / 1 = x;
x / x = 1.

4. Теория

Абстрактное синтаксическое дерево (АСД) — конечное помеченное ориентированное дерево, в котором внутренние вершины сопоставлены (помечены) с операторами языка программирования, а листья — с соответствующими операндами. Таким образом, листья являются пустыми операторами и представляют только переменные и константы. Трехадресный код принято хранить в виде списка трехадресных инструкций. При этом, трехадресная инструкция представляет собой пятерку: метку инструкции, операцию, первый аргумент, второй аргумент и возможная переменная-результат.

5. Реализация

Т.к. блок трехадресного кода представляет собой список трехадресных инструкций, оптимизатор блока представляет собой отдельный класс, который проходит по такому списку инструкций и изменяет их в соответствии с задачей. Так, оптимизатор алгебраических тождеств заменяет, например, инструкцию “a = b + 0” на инструкцию “a = b”. Ниже приведен фрагмент кода, отвечающий за оптимизацию инструкций, содержащих оператор “+”:

if (c.Operation.Equals("+"))
{               	 
if (c.Argument1.Equals("0"))
     {
     	c.Argument1 = c.Argument2;
     	c.Argument2 = "";
        c.Operation = "=";
     }
     else if (c.Argument2.Equals("0"))
     {
     	c.Argument2 = "";
        c.Operation = "=";
     }
} 

6. Интеграция в общий проект

Процедура оптимизации с использованием всех оптимизаторов TAC, проходит в специальном классе, инкапсулирующем в себе конвейер оптимизаций. Для интеграции отдельного оптимизатора в общий проект, необходимо просто добавить экземпляр данного оптимизатора в коллекцию оптимизаторов конвейера.

7. Тесты

Тестирование проходит следующим образом: сначала по заданной строке генерируется TAC-код, затем к нему применяется оптимизатор AlgebraicIdentitiesOptimizer, который запускается командой Run(). Затем оптимизированный TAC-код сравнивается с предполагаемым ответом. Пример:

[Test]
public void SimpleExample()
{
    var TAC = GenerateTAC(
@"
{
  x = x + 0;
}
");
    var AIOptimizer = new AlgebraicIdentitiesOptimizer(TAC);
    AIOptimizer.Run();
    var expected = new List<string>()
    {
        "#t0 = x", "x = #t0"
    };
    var actual = AIOptimizer.TAC.Instructions.Select(instruction =>                     
                                                    instruction.ToString().Trim());
    CollectionAssert.AreEqual(expected, actual);
}

1. Команда, реализующая задачу Чухин А. И., Агафонцев Р. Г.

2. Зависимые и предшествующие задачи

   Предшествующие:

• Трехадресный код

  Зависимые: -

3. Аннотация

Протянуть копии и константы где это возможно.

4. Теория

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

5. Реализация

Участок кода, отвечающий за работу с константами:

public void OptimizeConstants()
{
    var knownConstants = new HashSet<string>();
    var values = new Dictionary<string, string>();
    foreach (var current in Instructions)
    {
        if (!(current.Result.Equals("")))
        {
            if (knownConstants.Contains(current.Argument1))
            {
                current.Argument1 = values[current.Argument1];
            }
            if (knownConstants.Contains(current.Argument2))
            {
                current.Argument2 = values[current.Argument2];
            }
            if (!current.Result.Contains("#"))
            {
                if (current.Argument2 == "" 
                    && double.TryParse(current.Argument1, out double c))
                {
                    if (!current.Argument1.Contains("#"))
                    {
                        knownConstants.Add(current.Result);
                        values[current.Result] = current.Argument1;
                    }
                    else
                    {
                        knownConstants.Remove(current.Result);
                    }
                }
            }
        }
    else
    {
        if (current.Operation is "if goto" 
            || current.Operation is "goto")
            {
                knownConstants.Clear();
                values.Clear();
            }
        }
    }
}

Участок кода, отвечающий за работу с копиями:

public void OptimizeCopy()
{
    var knownVariables = new HashSet<string>();
    var values = new Dictionary<string, string>();
    foreach (var current in Instructions)
    {
        if (!current.Result.Equals(""))
        {
            if (knownVariables.Contains(current.Argument1))
            {
                current.Argument1 = values[current.Argument1];
            }

            if (knownVariables.Contains(current.Argument2))
            {
                current.Argument2 = values[current.Argument2];
            }

            if (!current.Result.Contains("#"))
            {
// если это буква
                if (current.Argument2 == "" 
                    && !double.TryParse(current.Argument1, out _))
                {
                    if (!current.Argument1.Contains("#"))
                    {
                        knownVariables.Add(current.Result);
                        values[current.Result] = current.Argument1;
                    }
                    else
                    {
                        knownVariables.Remove(current.Result);
                    }
                }
            }
        }
        else
        {
            if (current.Operation is "if goto" 
                || current.Operation is "goto")
            {
                knownVariables.Clear();
                values.Clear();
            }
        }
    }
}