Курсовые проекты / Soft / Common / TrdOpt

unit TrdOpt;

interface

{ Модуль реализующий два алгоритма оптимизации:
  - оптимизация путём свёртки объектного кода;
  - оптимизация за счёт исключения лишних операций. }
uses Classes, TblElem, LexElem, TrdType, Triads;

type
{ Информационная структура для таблицы идентификаторов,
  предназначенная для алгоритма свёртки объектного кода }
TConstInfo = class(TAddVarInfo)
 protected
  { Поле для записи значения переменной }
  iConst: longint;
  { Конструктор для создания структуры }
  constructor Create(iInfo: longint);
 public
  { Функции для чтения и записи информации }
  function GetInfo(iIdx: integer): longint; override;
  procedure SetInfo(iIdx: integer; iInfo: longint);
    override;
end;

{ Информационная структура для таблицы идентификаторов,
  предназначенная для алгоритма исключения лишних операций }
TDepInfo = class(TAddVarInfo)
 protected
  { Поле для записи числа зависимости переменной }
  iDep: longint;
  { Конструктор для создания структуры }
  constructor Create(iInfo: longint);
 public
  { Функции для чтения и записи информации }
  function GetInfo(iIdx: integer): longint; override;
  procedure SetInfo(iIdx: integer; iInfo: longint);
    override;
end;

{ Процедура оптимизации методом свёртки объектного кода }
procedure OptimizeConst(listTriad: TTriadList);
{ Процедура оптимизации методом
  исключения лишних операций }
procedure OptimizeSame(listTriad: TTriadList);

implementation

uses SysUtils, FncTree, LexType, TrdCalc;

constructor TConstInfo.Create(iInfo: longint);
{ Конструктор создания информационной структуры
  для свёртки объектного кода }
begin
  inherited Create;
  iConst := iInfo;
end;

procedure TConstInfo.SetInfo(iIdx: integer;
                             iInfo: longint);
{ Функция записи инфоримации }
begin
  iConst := iInfo;
end;

function TConstInfo.GetInfo(iIdx: integer): longint;
{ Функция чтения инфоримации }
begin
  Result := iConst;
end;

function TestOperConst(Op: TOperand; listTriad: TTriadList;
                       var iConst: integer): Boolean;
{ Функция проверки того, что операнд является константой
  и получения его значения в переменную iConst }
var pInfo: TConstInfo;
begin
  Result := False;
  { Выборка по типу операнда }
  case Op.OpType of
    OP_CONST:
    { Если оператор - константа, то всё просто... }
      begin
        iConst := Op.ConstVal;
        Result := True;
      end;
    OP_VAR:
    { Если оператор - переменная }
      begin
        { тогда проверяем наличие у нее
          информационной структуры }
        pInfo := TConstInfo(Op.VarLink.Info);
        if pInfo <> nil then
        begin
          { и если такая структура есть,
            берём ее значение }
          iConst := pInfo[0];
          Result := True;
        end;
      end;
    OP_LINK:
    { Если оператор - ссылка на триаду }
      begin
        { то он является константой,
          если триада имеет тип "CONST" }
        if listTriad[Op.TriadNum].TrdType = TRD_CONST
        then
        begin
          iConst := listTriad[Op.TriadNum][1].ConstVal;
          Result := True;
        end;
      end;
  end{case};
end;

procedure OptimizeConst(listTriad: TTriadList);
{ Процедура оптимизации методом свёртки объектного кода }
var
  i,j,iCnt,iOp1,iOp2: integer;
  Ops: TOpArray;
  Trd: TTriad;
begin
  { Очищаем информационные структуры
    таблицы идентификаторов }
  ClearTreeInfo;
  { Заполняем операнды для триады типа "CONST" }
  Ops[1].OpType   := OP_CONST;
  Ops[2].OpType   := OP_CONST;
  Ops[2].ConstVal := 0;
  iCnt := listTriad.Count-1;
  { Для всех триад списка выполняем алгоритм }
  for i:=0 to iCnt do
  begin
    Trd := listTriad[i];
    if Trd.TrdType in TriadLineSet then
    begin
      { Если любой операнд линейной триады ссылается
        на триаду типа "CONST",
        то берём и запоминаем её значение }
      for j:=1 to 2 do
       if (Trd[j].OpType = OP_LINK)
        and (listTriad[Trd.Links[j]].TrdType = TRD_CONST)
       then
       begin
         Trd.OpTypes[j] := OP_CONST;
         Trd.Values[j]  :=
           listTriad[Trd.Links[j]][1].ConstVal;
       end;
    end
    else
    if Trd.TrdType = TRD_IF then
    begin
      { Если первый операнд условной триады ссылается
        на триаду типа "CONST",
        то берём и запоминаем её значение }
      if (Trd[1].OpType = OP_LINK)
       and (listTriad[Trd.Links[1]].TrdType = TRD_CONST)
      then
      begin
        Trd.OpTypes[1] := OP_CONST;
        Trd.Values[1]  :=
          listTriad[Trd.Links[1]][1].ConstVal;
      end;
    end
    else
    if Trd.TrdType = TRD_ASSIGN then
    begin
      { Если второй операнд триады присвоения
        ссылается на триаду типа "CONST",
        то берём и запоминаем её значение }
      if (Trd[2].OpType = OP_LINK)
       and (listTriad[Trd.Links[2]].TrdType = TRD_CONST)
      then
      begin
        Trd.OpTypes[2] := OP_CONST;
        Trd.Values[2]  :=
          listTriad[Trd.Links[2]][1].ConstVal;
      end;
    end;
    { Если триада помечена ссылкой, то линейный участок
      кода закончен - опять очищаем информационные
      структуры таблицы идентификаторов }
    if Trd.IsLinked then ClearTreeInfo;
    { Если триада имеет тип "присвоение" }
    if Trd.TrdType = TRD_ASSIGN then
    begin
      { И если её второй операнд - константа }
      if TestOperConst(Trd[2],listTriad,iOp2) then
       { запоминаем его значение в информационной
         структуре переменной }
       Trd[1].VarLink.Info := TConstInfo.Create(iOp2);
    end
    else
    { Если триада - одна из линейных операций }
    if Trd.TrdType in TriadLineSet then
    begin
      { И если оба её операнда - константы }
      if TestOperConst(Trd[1],listTriad,iOp1)
      and TestOperConst(Trd[2],listTriad,iOp2) then
      begin
        { тогда вычисляем значение операции }
        Ops[1].ConstVal :=
          CalcTriad(Trd.TrdType,iOp1,iOp2);
        { запоминаем его в триаде типа "CONST",
          которую записываем в список
          вместо прежней триады }
        listTriad.Items[i] := TTriad.Create(TRD_CONST,Ops);
        { Если на прежнюю триаду была ссылка,
          сохраняем её }
        listTriad[i].IsLinked := Trd.IsLinked;
        { Уничтожаем прежнюю триаду }
        Trd.Free;
      end;
    end;
  end;
end;

constructor TDepInfo.Create(iInfo: longint);
{ Конструктор создания информационной структуры
  для чисел зависимости }
begin
  inherited Create;
  iDep := iInfo;
end;

procedure TDepInfo.SetInfo(iIdx: integer; iInfo: longint);
{ Функция записи числа зависимости }
begin
  iDep := iInfo;
end;

function TDepInfo.GetInfo(iIdx: integer): longint;
{ Функция чтения числа зависимости }
begin
  Result := iDep;
end;

function CalcDepOp(listTriad: TTriadList;
                   Op: TOperand): longint;
{ Функция вычисления числа зависимости
  для операнда триады }
begin
  Result := 0;
  { Выборка по типу операнда }
  case Op.OpType of
    OP_VAR:
    { Если это переменная - смотрим ее информационную
      структуру, и если такая структура есть,
      то берем оттуда число зависимости }
      if Op.VarLink.Info <> nil then Result :=
       Op.VarLink.Info.Info[0];
    OP_LINK:
    { Если это ссылка на триаду,
      то берем число зависимости триады }
      Result := listTriad[Op.TriadNum].Info;
  end{case};
end;

function CalcDep(listTriad: TTriadList;
                 Trd: TTriad): longint;
{ Функция вычисления числа зависимости триады }
var iDepTmp: longint;
begin
  Result  := CalcDepOp(listTriad,Trd[1]);
  iDepTmp := CalcDepOp(listTriad,Trd[2]);
  { Число зависимости триады есть на единицу большее,
    чем максимальное из чисел зависимости её операндов }
  if iDepTmp > Result then Result := iDepTmp+1
  else Inc(Result);
  Trd.Info := Result;
end;

procedure OptimizeSame(listTriad: TTriadList);
{ Процедура оптимизации методом исключения
  лишних операций }
var
  i,j,iStart,iCnt,iNum: integer;
  Ops: TOpArray;
  Trd: TTriad;
begin
  { Ставим начало линейного участка равным
    началу списка триад }
  iStart := 0;
  { Очищаем информационные структуры
    таблицы идентификаторов }
  ClearTreeInfo;
  iCnt := listTriad.Count-1;
  { Заполняем операнды для триады типа "SAME" }
  Ops[1].OpType   := OP_LINK;
  Ops[2].OpType   := OP_CONST;
  Ops[2].ConstVal := 0;
  { Для всех триад списка выполняем алгоритм }
  for i:=0 to iCnt do
  begin
    Trd := listTriad[i];
    { Если триада помечена ссылкой, то линейный участок
      кода закончен - опять очищаем информационные
      структуры таблицы идентификаторов,
      и запоминаем начало нового линейного участка }
    if Trd.IsLinked then
    begin
      ClearTreeInfo;
      iStart := i;
    end;
    { Если любой операнд триады ссылается на триаду
      типа "SAME", то переставляем ссылку на предыдущую,
      совпадающую с ней триаду }
    for j:=1 to 2 do
     if Trd[j].OpType = OP_LINK then
     begin
       iNum := Trd[j].TriadNum;
       if listTriad[iNum].TrdType = TRD_SAME then
        Trd.Links[j] := listTriad[iNum].Links[1];
     end;
    { Если триада типа "присвоение",
      то запоминаем число зависимости переменной }
    if Trd.TrdType = TRD_ASSIGN then
    begin
      Trd[1].VarLink.Info := TDepInfo.Create(i+1);
    end
    else
    { Если триада - одна из линейных операций }
    if Trd.TrdType in TriadLineSet then
    begin
      { Вычисляем число зависимости триады }
      CalcDep(listTriad,Trd);
      { На всем линейном участке ищем совпадающую с ней
        триаду с таким же числом зависимости }
      for j:=iStart to i-1 do
      begin
        if Trd.IsEqual(listTriad[j])
         and (Trd.Info = listTriad[j].Info) then
        begin
          { Если такая триада найдена, запоминаем
            ссылку на нее }
          Ops[1].TriadNum := j;
          { запоминаем её в триаде типа "SAME", которую
            записываем в список вместо прежней триады }
          listTriad.Items[i] :=
            TTriad.Create(TRD_SAME,Ops);
          { Если на прежнюю триаду была ссылка,
            сохраняем её }
          listTriad[i].IsLinked := Trd.IsLinked;
          { Уничтожаем прежнюю триаду }
          Trd.Free;
          { Прерываем поиск }
          Break;
        end;
      end;
    end{if};
  end{for};
end;

end.