MicroTESK

h1. Язык Ruby-MT описания шаблонов тестовых программ

Язык *Ruby-MT (Ruby for MicroTESK)* предназначен для компактного и переиспользуемого описания функциональных тестов для микропроцессоров и других программируемых устройств. Язык представляет собой смесь языка ассемблера целевого микропроцессора (*TL, Target Language*) и управляющего языка высокого уровня (*ML, Meta Language*). При этом ML можно рассматривать как макропроцессор, поскольку в результате выполнения его конструкций генерируется текст на TL. Язык построен на основе Ruby в форме библиотечного расширения (не требуется дополнительных парсеров и т.п.).

Код на Ruby-MT описывает шаблон тестовой программы (далее для краткости шаблон). Обработка шаблона состоит из следующих шагов:

# Препроцессирование шаблона.

# Выполнение шаблона.

При выполнении шаблона, он генерирует программу путем обращения к базе данных ограничений, солверам и другим стандартным компонентам генератора через *API генератора*.

h2. Интуитивное описание языка на примерах

h3. Пример 1 (MIPS)

<pre>

class MyTemplate < MipsTemplate

    # В базовом шаблоне содержатся общие инструкции инициализации микропроцессора

    def initialize()

        super()

    end

    # Главный метод теста

    def test()

        # Повторить в тестовой программе 100 раз следующую ситуацию

        100.times {

            # Добавление в тестовую программу комментария

            text(''# --------------------------------------------------------------------------------'');

            # Загрузка в регистр reg1 содержимого памяти по адресу, содержащемуся в регистре base1

            # Функция r выделяет новый регистр общего назначения

            ld reg1=r, 0x0(base1=r)  ;; goal([l1Hit,50],[!l1Hit,50])        # Попадание в кэш-память L1 осуществляются с вероятностью 50%

            # Загрузка в регистр reg2 содержимого памяти по адресу, содержащемуся в регистре base2

            ld reg2=r, 0x0(base2=r)  ;; goal(l1Hit && !equal(base1, base2)) # Адреса первой и второй интрукции загрузки не должны совпадать ([base1] != [base2])

            # Запись результата сложения содержимого регистров reg1 и reg2 в регистр res

            dadd res=r, reg1, reg2   ;; goal(!integerOverflow)              # При сложении не должно возникать переполнения

        }

    end

    # В базовом шаблоне содержатся общие инструкции завершения работы микропроцессора

    def finalize()

        super.finalize()

    end

end

</pre>

В результате обработки этого шаблона будет сгенерирована программа следующего вида.

<pre>

...

# --------------------------------------------------------------------------------

ld reg001_1, 0x0(base001_1)

ld reg001_2, 0x0(base001_2)

dadd res001, reg001_1, reg001_2

...

# --------------------------------------------------------------------------------

ld reg100_1, 0x0(base100_1)

ld reg100_2, 0x0(base100_2)

dadd res100, reg100_1, reg100_2

...

</pre>

В этой программе @regXXX_{1,2}@, @baseXXX_{1,2}@ и @resXXX@ - это регистры общего назначения (некоторые из них совпадают друг с другом). В начале программы (возможно, и в некоторых промежуточных точках) располагается *управляющий код*, инициализирующий регистры и память так, чтобы удовлетворить заданным в шаблоне ограничениям.

>> *TODO:* нужно переопределить операции для тестовых ситуаций (!, &&, ||).

>> *TODO:* пока можно ограничиться случаем одной тестовой ситуации в @goal()@.

h2. Распределение регистров

Для каждого типа регистров (@GPR@, @FPR@ и т.п.) определена *функция распределения регистров* (например, функция @r@ в примере выше). Эта функция имеет один целочисленный параметр - номер регистра. Если параметр не указан, функция выделяет регистр согласно некоторой *стратегии распределения регистров*. В основной стратегии при каждом вызове возвращается случайно выбранный не занятый регистр (возвращаемый регистр помечается как занятый). Поскольку регистров конечное число, не исключены случаи, когда все регистры заняты.

Для распределения регистров в программе используются следующие правила:

*1. Если в качестве регистра в шаблоне используется конкретный регистр, а не переменная, то этот регистр используется и в сгенерированной программе.*

Например, для шаблона

<pre>

ori @r, r0, 0x0

</pre>

второй регистр инструкции @ori@ (регистр @r0@) фиксирован. Примером программы, соответствующей этому шаблону является

<pre>

ori r7, r0, 0x0 # Регистр r0 фиксирован

</pre>

*2. Если имена переменных, обозначающих регистры, в шаблоне совпадают (в пределах одной области видимости), то в соответствующих частях итоговой программы будет использоваться один и тот же регистр.*

Например, для шаблона

<pre>

2.times {

    add @r1, @r2, @r3

    sub @r4, @r1, @r5 # Результат сложения используется в качестве вычитаемого

}

</pre>

первый регистр инструкции @add@ всегда будет совпадать со вторым регистром инструкции @sub@, хотя эти регистры могут быть разными на разных итерациях:

<pre>

# --------------------------------------------------------------------------------

add r2,  r10, r5

sub r9,  r2,  r15 # Зависимость по регистру r2

# --------------------------------------------------------------------------------

add r11, r27, r9

sub r9,  r11, r23 # Зависимость по регистру r11

</pre>

Более сложный пример

<pre>

ori @r1, r0, 0x0

2.times {

    add @r1, @r2, @r3 # Результат сложения заносится в тот же регистр, что и результат вышестоящей инструкции

    sub @r4, @r1, @r5 # Результат сложения используется в качестве вычитаемого

}

</pre>

В этот случае регистры @@r1@ на первой и второй итерациях будут совпадать между собой и будут равны первому регистру инструкции @ori@.

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

<pre>

2.times {

    add @r1, @r2, @r3

}

2.times {

    add @r1, @r2, @r3 # Зависимости по регистрам нет

}

</pre>

*3. Если имена переменных, обозначающих регистры, в шаблоне различаются, либо переменные находятся в разных областях видимости, либо для обозначения регистра используется символ @*@, то в соответствующих частях итоговой программы возможны совпадающие регистры.*

Регистров ограниченное число, поэтому пересечения по регистрам неизбежны. По возможности, внутри одного блока используются разные регистры. *Стратегию распределения регистров нужно обдумать.*