← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/hipe/regalloc/hipe_optimistic_regalloc.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-08-05 20:54:29 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090805205429-pm4pnwew8axraosl
Tags: 1:13.b.1-dfsg-5
http://bugs.debian.org/536891
* Fixed parentheses in Emacs mode (closes: #536891).
* Removed unnecessary conflicts with erlang-manpages package.
* Added workaround for #475459: disabled threads on sparc architecture.
  This breaks wxErlang, so it's only a temporary solution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hipe/regalloc/hipe_optimistic_regalloc.erl
945
945
splits([L|Ls], SavedSpillCosts) ->
946
946
  Spl = splits(Ls, SavedSpillCosts),
947
947
  SpillCost = hipe_spillcost:spill_cost(L, SavedSpillCosts),
948
 
  Spl1 = lists:map(fun({Cols, NonCols, OldSpillCost}) ->
949
 
                       {[L|Cols], NonCols, OldSpillCost}
950
 
                   end, Spl),
951
 
  Spl2 = lists:map(fun({Cols, NonCols, OldSpillCost}) ->
952
 
                       {Cols, [L|NonCols], OldSpillCost + SpillCost}
953
 
                   end, Spl),
 
948
  Spl1 = [splits_1(S, L) || S <- Spl],
 
949
  Spl2 = [splits_2(S, L, SpillCost) || S <- Spl],
954
950
  spillCostOrderedMerge(Spl1, Spl2, []).
955
951
 
 
952
splits_1({Cols, NonCols, OldSpillCost}, L) ->
 
953
    {[L|Cols], NonCols, OldSpillCost}.
 
954
 
 
955
splits_2({Cols, NonCols, OldSpillCost}, L, SpillCost) ->
 
956
    {Cols, [L|NonCols], OldSpillCost + SpillCost}.
 
957
 
956
958
%% Merge two ordered sub-splits into one.
957
959
 
958
960
spillCostOrderedMerge(Spl1, [], Spl) ->
1865
1867
 
1866
1868
selectSpill(WorkLists, IG, SpillLimit) ->
1867
1869
  [CAR|CDR] = hipe_reg_worklists:spill(WorkLists),
1868
 
  
1869
1870
  SpillCost = getCost(CAR, IG, SpillLimit),
1870
1871
  M = findCheapest(CDR, IG, SpillCost, CAR, SpillLimit),
1871
 
  
1872
1872
  WorkLists1 = hipe_reg_worklists:remove_spill(M, WorkLists),
1873
 
  WorkLists2 = hipe_reg_worklists:add_simplify(M, WorkLists1),
1874
 
  WorkLists2.
 
1873
  hipe_reg_worklists:add_simplify(M, WorkLists1).
1875
1874
 
1876
1875
%%---------------------------------------------------------------------
1877
1876
%% Function:    selectSpill
1924
1923
 
1925
1924
getCost(Node, IG, SpillLimit) ->
1926
1925
  case Node > SpillLimit of
1927
 
    true ->  inf;
 
1926
    true -> inf;
1928
1927
    false ->
1929
1928
      SpillCost = hipe_ig:node_spill_cost(Node, IG),
1930
1929
      ?debug_msg("Actual spillcost f node ~w is ~w~n", [Node, SpillCost]),
1953
1952
%%----------------------------------------------------------------------
1954
1953
 
1955
1954
-ifdef(COMPARE_ITERATED_OPTIMISTIC).
1956
 
freeze(K,WorkLists,Moves,IG,Alias) ->
 
1955
freeze(K, WorkLists, Moves, IG, Alias) ->
1957
1956
  [U|_] = hipe_reg_worklists:freeze(WorkLists),         % Smarter routine?
1958
 
  ?debug_msg("freezing node ~p~n",[U]),
 
1957
  ?debug_msg("freezing node ~p~n", [U]),
1959
1958
  WorkLists0 = hipe_reg_worklists:remove_freeze(U, WorkLists),
1960
1959
  %% The published algorithm adds U to the simplify worklist
1961
1960
  %% before the freezeMoves() call. That breaks the worklist
1962
1961
  %% invariants, which is why the order is switched here.
1963
 
  {WorkLists1,Moves1} = freezeMoves(U,K,WorkLists0,Moves,IG,Alias),
 
1962
  {WorkLists1, Moves1} = freezeMoves(U, K, WorkLists0, Moves, IG, Alias),
1964
1963
  WorkLists2 = hipe_reg_worklists:add_simplify(U, WorkLists1),
1965
 
  {WorkLists2,Moves1}.
 
1964
  {WorkLists2, Moves1}.
1966
1965
-endif.
1967
1966
 
1968
1967
%%----------------------------------------------------------------------
1986
1985
%%----------------------------------------------------------------------
1987
1986
 
1988
1987
-ifdef(COMPARE_ITERATED_OPTIMISTIC).
1989
 
freezeMoves(U,K,WorkLists,Moves,IG,Alias) ->
 
1988
freezeMoves(U, K, WorkLists, Moves, IG, Alias) ->
1990
1989
  Nodes = hipe_moves:node_moves(U, Moves),
1991
 
  freezeEm(U,Nodes,K,WorkLists,Moves,IG,Alias).
 
1990
  freezeEm(U, Nodes, K, WorkLists, Moves, IG, Alias).
1992
1991
 
1993
1992
%% Find what the other value in a copy instruction is, return false if 
1994
1993
%% the instruction isn't a move with the first argument in it.
2011
2010
     true -> exit({?MODULE,moves}) % XXX: shouldn't happen
2012
2011
  end.
2013
2012
 
2014
 
freezeEm(_U,[],_K,WorkLists,Moves,_IG,_Alias) -> 
 
2013
freezeEm(_U, [], _K, WorkLists, Moves, _IG, _Alias) -> 
2015
2014
  {WorkLists,Moves};
2016
 
freezeEm(U,[M|Ms],K,WorkLists,Moves,IG,Alias) ->
 
2015
freezeEm(U, [M|Ms], K, WorkLists, Moves, IG, Alias) ->
2017
2016
  V = moves(U, M, Alias, Moves),
2018
 
  {WorkLists2,Moves2} = freezeEm2(U,V,M,K,WorkLists,
2019
 
                                  Moves,IG,Alias),
2020
 
  freezeEm(U,Ms,K,WorkLists2,Moves2,IG,Alias).
 
2017
  {WorkLists2,Moves2} = freezeEm2(U, V, M, K, WorkLists, Moves, IG, Alias),
 
2018
  freezeEm(U, Ms, K, WorkLists2, Moves2, IG, Alias).
2021
2019
 
2022
 
freezeEm2(U,V,M,K,WorkLists,Moves,IG,Alias) ->
 
2020
freezeEm2(U, V, M, K, WorkLists, Moves, IG, Alias) ->
2023
2021
  case hipe_moves:member_active(M, Moves) of
2024
2022
    true ->
2025
2023
      Moves1 = hipe_moves:remove_active(M, Moves),
2026
 
      freezeEm3(U,V,M,K,WorkLists,Moves1,IG,Alias);     
 
2024
      freezeEm3(U, V, M, K, WorkLists, Moves1, IG, Alias);      
2027
2025
    false ->
2028
2026
      Moves1 = hipe_moves:remove_worklist(M, Moves),
2029
 
      freezeEm3(U,V,M,K,WorkLists,Moves1,IG,Alias)
 
2027
      freezeEm3(U, V, M, K, WorkLists, Moves1, IG, Alias)
2030
2028
  end.
2031
2029
 
2032
2030
freezeEm3(_U,V,_M,K,WorkLists,Moves,IG,_Alias) ->