Merge branch 'dgud/observer/opt-tv-tab/OTP-14856' into maint

* dgud/observer/opt-tv-tab/OTP-14856:
  observer: Fix change accum
  Remove double calls
  observer: Don't crash for late messages
  observer: Optimize tv tab for many tables

4 files changed, 236 insertions, 131 deletions

diff --git a/lib/observer/src/observer_pro_wx.erl b/lib/observer/src/observer_pro_wx.erl
index d612e0a1c5..1c40afba46 100644
--- a/lib/observer/src/observer_pro_wx.erl
+++ b/lib/observer/src/observer_pro_wx.erl
@@ -572,7 +572,8 @@ change_accum(true, S0) ->
     S0#holder{accum=true};
 change_accum(false, S0=#holder{info=Info}) ->
     self() ! refresh,
-    S0#holder{accum=lists:sort(array:to_list(Info))}.
+    Accum = [{Pid, Reds} || #etop_proc_info{pid=Pid, reds=Reds} <- array:to_list(Info)],
+    S0#holder{accum=lists:sort(Accum)}.
 
 handle_update_old(#etop_info{procinfo=ProcInfo0},
                   S0=#holder{parent=Parent, sort=Sort=#sort{sort_key=KeyField}}) ->
diff --git a/lib/observer/src/observer_procinfo.erl b/lib/observer/src/observer_procinfo.erl
index 854f338a89..5bc17e2aee 100644
--- a/lib/observer/src/observer_procinfo.erl
+++ b/lib/observer/src/observer_procinfo.erl
@@ -257,8 +257,6 @@ init_stack_page(Parent, Pid) ->
 					      [Pid, current_stacktrace])
 		     of
 			 {current_stacktrace,RawBt} ->
-			     observer_wx:try_rpc(node(Pid), erlang, process_info,
-						 [Pid, current_stacktrace]),
 			     wxListCtrl:deleteAllItems(LCtrl),
 			     wx:foldl(fun({M, F, A, Info}, Row) ->
 					      _Item = wxListCtrl:insertItem(LCtrl, Row, ""),
diff --git a/lib/observer/src/observer_tv_wx.erl b/lib/observer/src/observer_tv_wx.erl
index e16f3cab6b..2e387f7e74 100644
--- a/lib/observer/src/observer_tv_wx.erl
+++ b/lib/observer/src/observer_tv_wx.erl
@@ -38,13 +38,13 @@
 -define(ID_SYSTEM_TABLES, 406).
 -define(ID_TABLE_INFO, 407).
 -define(ID_SHOW_TABLE, 408).
- 
--record(opt, {type=ets,
-	      sys_hidden=true,
-	      unread_hidden=true,
-	      sort_key=2,
-	      sort_incr=true
-	     }).
+
+-record(opts, {type=ets,
+               sys_hidden=true,
+               unread_hidden=true}).
+
+-record(sort, {sort_incr=true,
+               sort_key=2}).
 
 -record(state,
 	{
@@ -52,9 +52,9 @@
 	  grid,
 	  panel,
 	  node=node(),
-	  opt=#opt{},
+	  opts=#opts{},
+          holder,
 	  selected,
-	  tabs,
 	  timer
 	}).
 
@@ -64,8 +64,18 @@ start_link(Notebook,  Parent, Config) ->
 init([Notebook, Parent, Config]) ->
     Panel = wxPanel:new(Notebook),
     Sizer = wxBoxSizer:new(?wxVERTICAL),
-    Style = ?wxLC_REPORT bor ?wxLC_SINGLE_SEL bor ?wxLC_HRULES,
-    Grid = wxListCtrl:new(Panel, [{winid, ?GRID}, {style, Style}]),
+
+    Opts=#opts{type=maps:get(type, Config, ets),
+               sys_hidden=maps:get(sys_hidden, Config, true),
+               unread_hidden=maps:get(unread_hidden, Config, true)},
+
+    Style = ?wxLC_REPORT bor ?wxLC_VIRTUAL bor ?wxLC_SINGLE_SEL bor ?wxLC_HRULES,
+    Self = self(),
+    Attrs = observer_lib:create_attrs(),
+    Holder = spawn_link(fun() -> init_table_holder(Self, Attrs) end),
+    CBs = [{onGetItemText, fun(_, Item,Col) -> get_row(Holder, Item, Col) end},
+           {onGetItemAttr, fun(_, Item) -> get_attr(Holder, Item) end}],
+    Grid = wxListCtrl:new(Panel, [{winid, ?GRID}, {style, Style} | CBs]),
     wxSizer:add(Sizer, Grid, [{flag, ?wxEXPAND bor ?wxALL},
 			      {proportion, 1}, {border, 5}]),
     wxWindow:setSizer(Panel, Sizer),
@@ -95,38 +105,26 @@ init([Notebook, Parent, Config]) ->
 
     wxWindow:setFocus(Grid),
     {Panel, #state{grid=Grid, parent=Parent, panel=Panel,
-                   timer=Config,
-                   opt=#opt{type=maps:get(type, Config, ets),
-                            sys_hidden=maps:get(sys_hidden, Config, true),
-                            unread_hidden=maps:get(unread_hidden, Config, true)}
-                  }}.
+                   opts=Opts, timer=Config, holder=Holder}}.
 
 handle_event(#wx{id=?ID_REFRESH},
-	     State = #state{node=Node, grid=Grid, opt=Opt}) ->
-    Tables = get_tables(Node, Opt),
-    {Tabs,Sel} = update_grid(Grid, sel(State), Opt, Tables),
-    Sel =/= undefined andalso wxListCtrl:ensureVisible(Grid, Sel),
-    {noreply, State#state{tabs=Tabs, selected=Sel}};
+	     State = #state{holder=Holder, node=Node, opts=Opts}) ->
+    Tables = get_tables(Node, Opts),
+    Holder ! {refresh, Tables},
+    {noreply, State};
 
 handle_event(#wx{event=#wxList{type=command_list_col_click, col=Col}},
-	     State = #state{node=Node, grid=Grid,
-			    opt=Opt0=#opt{sort_key=Key, sort_incr=Bool}}) ->
-    Opt = case col2key(Col) of
-	      Key -> Opt0#opt{sort_incr=not Bool};
-	      NewKey -> Opt0#opt{sort_key=NewKey}
-	  end,
-    Tables = get_tables(Node, Opt),
-    {Tabs,Sel} = update_grid(Grid, sel(State), Opt, Tables),
-    wxWindow:setFocus(Grid),
-    {noreply, State#state{opt=Opt, tabs=Tabs, selected=Sel}};
+	     State = #state{holder=Holder}) ->
+    Holder ! {sort, Col},
+    {noreply, State};
 
-handle_event(#wx{id=Id}, State = #state{node=Node, grid=Grid, opt=Opt0})
+handle_event(#wx{id=Id}, State = #state{node=Node, holder=Holder, grid=Grid, opts=Opt0})
   when Id >= ?ID_ETS, Id =< ?ID_SYSTEM_TABLES ->
     Opt = case Id of
-	      ?ID_ETS -> Opt0#opt{type=ets};
-	      ?ID_MNESIA -> Opt0#opt{type=mnesia};
-	      ?ID_UNREADABLE -> Opt0#opt{unread_hidden= not Opt0#opt.unread_hidden};
-	      ?ID_SYSTEM_TABLES -> Opt0#opt{sys_hidden= not Opt0#opt.sys_hidden}
+	      ?ID_ETS -> Opt0#opts{type=ets};
+	      ?ID_MNESIA -> Opt0#opts{type=mnesia};
+	      ?ID_UNREADABLE -> Opt0#opts{unread_hidden= not Opt0#opts.unread_hidden};
+	      ?ID_SYSTEM_TABLES -> Opt0#opts{sys_hidden= not Opt0#opts.sys_hidden}
 	  end,
     case get_tables2(Node, Opt) of
 	Error = {error, _} ->
@@ -135,9 +133,9 @@ handle_event(#wx{id=Id}, State = #state{node=Node, grid=Grid, opt=Opt0})
 	    self() ! Error,
 	    {noreply, State};
 	Tables ->
-	    {Tabs, Sel} = update_grid(Grid, sel(State), Opt, Tables),
+	    Holder ! {refresh, Tables},
 	    wxWindow:setFocus(Grid),
-	    {noreply, State#state{opt=Opt, tabs=Tabs, selected=Sel}}
+	    {noreply, State#state{opts=Opt}}
     end;
 
 handle_event(#wx{event=#wxSize{size={W,_}}},  State=#state{grid=Grid}) ->
@@ -146,19 +144,18 @@ handle_event(#wx{event=#wxSize{size={W,_}}},  State=#state{grid=Grid}) ->
 
 handle_event(#wx{event=#wxList{type=command_list_item_activated,
 			       itemIndex=Index}},
-	     State=#state{grid=Grid, node=Node, opt=#opt{type=Type}, tabs=Tabs}) ->
-    Table = lists:nth(Index+1, Tabs),
-    case Table#tab.protection of
-	private ->
-	    self() ! {error, "Table has 'private' protection and can not be read"};
-	_ ->
-	    observer_tv_table:start_link(Grid, [{node,Node}, {type,Type}, {table,Table}])
+	     State=#state{holder=Holder, node=Node, opts=#opts{type=Type}, grid=Grid}) ->
+    case get_table(Holder, Index) of
+        #tab{protection=private} ->
+            self() ! {error, "Table has 'private' protection and can not be read"};
+        #tab{}=Table ->
+	    observer_tv_table:start_link(Grid, [{node,Node}, {type,Type}, {table,Table}]);
+        _ -> ignore
     end,
     {noreply, State};
 
 handle_event(#wx{event=#wxList{type=command_list_item_right_click}},
 	     State=#state{panel=Panel}) ->
-
     Menu = wxMenu:new(),
     wxMenu:append(Menu, ?ID_TABLE_INFO, "Table info"),
     wxMenu:append(Menu, ?ID_SHOW_TABLE, "Show Table Content"),
@@ -167,32 +164,33 @@ handle_event(#wx{event=#wxList{type=command_list_item_right_click}},
     {noreply, State};
 
 handle_event(#wx{event=#wxList{type=command_list_item_selected, itemIndex=Index}},
-	     State) ->
+	     State=#state{holder=Holder}) ->
+    Holder ! {selected, Index},
     {noreply, State#state{selected=Index}};
 
 handle_event(#wx{id=?ID_TABLE_INFO},
-	     State = #state{grid=Grid, node=Node, opt=#opt{type=Type}, tabs=Tabs, selected=Sel}) ->
+	     State = #state{holder=Holder, grid=Grid, node=Node, opts=#opts{type=Type}, selected=Sel}) ->
     case Sel of
 	undefined ->
 	    {noreply, State};
 	R when is_integer(R) ->
-	    Table = lists:nth(Sel+1, Tabs),
+	    Table = get_table(Holder, Sel),
 	    display_table_info(Grid, Node, Type, Table),
 	    {noreply, State}
     end;
 
 handle_event(#wx{id=?ID_SHOW_TABLE},
-	     State=#state{grid=Grid, node=Node, opt=#opt{type=Type}, tabs=Tabs, selected=Sel}) ->
+	     State=#state{holder=Holder, grid=Grid, node=Node, opts=#opts{type=Type}, selected=Sel}) ->
     case Sel of
 	undefined ->
 	    {noreply, State};
 	R when is_integer(R) ->
-	    Table = lists:nth(Sel+1, Tabs),
-	    case Table#tab.protection of
-		private ->
+	    case get_table(Holder, R) of
+		#tab{protection=private} ->
 		    self() ! {error, "Table has 'private' protection and can not be read"};
-		_ ->
-		    observer_tv_table:start_link(Grid, [{node,Node}, {type,Type}, {table,Table}])
+                #tab{}=Table ->
+		    observer_tv_table:start_link(Grid, [{node,Node}, {type,Type}, {table,Table}]);
+                _ -> ignore
 	    end,
 	    {noreply, State}
     end;
@@ -202,14 +200,14 @@ handle_event(#wx{id=?ID_REFRESH_INTERVAL},
     Timer = observer_lib:interval_dialog(Grid, Timer0, 10, 5*60),
     {noreply, State#state{timer=Timer}};
 
-handle_event(Event, _State) ->
-    error({unhandled_event, Event}).
+handle_event(_Event, State) ->
+    {noreply, State}.
 
 handle_sync_event(_Event, _Obj, _State) ->
     ok.
 
-handle_call(get_config, _, #state{timer=Timer, opt=Opt}=State) ->
-    #opt{type=Type, sys_hidden=Sys, unread_hidden=Unread} = Opt,
+handle_call(get_config, _, #state{timer=Timer, opts=Opt}=State) ->
+    #opts{type=Type, sys_hidden=Sys, unread_hidden=Unread} = Opt,
     Conf0 = observer_lib:timer_config(Timer),
     Conf = Conf0#{type=>Type, sys_hidden=>Sys, unread_hidden=>Unread},
     {reply, Conf, State};
@@ -220,50 +218,68 @@ handle_call(Event, From, _State) ->
 handle_cast(Event, _State) ->
     error({unhandled_cast, Event}).
 
-handle_info(refresh_interval, State = #state{node=Node, grid=Grid, opt=Opt,
-                                             tabs=OldTabs}) ->
-    case get_tables(Node, Opt) of
-        OldTabs ->
-            %% no change
-            {noreply, State};
-        Tables ->
-            {Tabs, Sel} = update_grid(Grid, sel(State), Opt, Tables),
-            Sel =/= undefined andalso wxListCtrl:ensureVisible(Grid, Sel),
-            {noreply, State#state{tabs=Tabs, selected=Sel}}
-    end;
+handle_info(refresh_interval, State = #state{holder=Holder, node=Node, opts=Opt}) ->
+    Tables = get_tables(Node, Opt),
+    Holder ! {refresh, Tables},
+    {noreply, State};
 
-handle_info({active, Node}, State = #state{parent=Parent, grid=Grid, opt=Opt0,
-					   timer=Timer0}) ->
-    {Tables, Opt} = case Opt0#opt.type =:= mnesia andalso get_tables2(Node, Opt0) of
+handle_info({active, Node}, State = #state{parent=Parent, holder=Holder, grid=Grid,
+                                           opts=Opt0, timer=Timer0}) ->
+    {Tables, Opt} = case Opt0#opts.type =:= mnesia andalso get_tables2(Node, Opt0) of
                         Ts when is_list(Ts) ->
                             {Ts, Opt0};
                         _ -> % false or error getting mnesia tables
-                            Opt1 = Opt0#opt{type=ets},
+                            Opt1 = Opt0#opts{type=ets},
                             {get_tables(Node, Opt1), Opt1}
                     end,
-    {Tabs,Sel} = update_grid(Grid, sel(State), Opt, Tables),
+    Holder ! {refresh, Tables},
     wxWindow:setFocus(Grid),
     create_menus(Parent, Opt),
     Timer = observer_lib:start_timer(Timer0, 10),
-    {noreply, State#state{node=Node, tabs=Tabs, timer=Timer, opt=Opt, selected=Sel}};
+    {noreply, State#state{node=Node, timer=Timer, opts=Opt}};
 
 handle_info(not_active, State = #state{timer = Timer0}) ->
     Timer = observer_lib:stop_timer(Timer0),
     {noreply, State#state{timer=Timer}};
 
-handle_info({error, Error}, #state{panel=Panel,opt=Opt}=State) ->
+handle_info({error, Error}, #state{panel=Panel,opts=Opt}=State) ->
     Str = io_lib:format("ERROR: ~ts~n",[Error]),
     observer_lib:display_info_dialog(Panel,Str),
-    case Opt#opt.type of
+    case Opt#opts.type of
         mnesia -> wxMenuBar:check(observer_wx:get_menubar(), ?ID_ETS, true);
         _ -> ok
     end,
-    {noreply, State#state{opt=Opt#opt{type=ets}}};
+    {noreply, State#state{opts=Opt#opts{type=ets}}};
+
+handle_info({refresh, Min, Min}, State = #state{grid=Grid}) ->
+    wxListCtrl:setItemCount(Grid, Min+1),
+    wxListCtrl:refreshItem(Grid, Min), %% Avoid assert in wx below if Max is 0
+    observer_wx:set_status(io_lib:format("Tables: ~w", [Min+1])),
+    {noreply, State};
+handle_info({refresh, Min, Max}, State = #state{grid=Grid}) ->
+    wxListCtrl:setItemCount(Grid, Max+1),
+    Max > 0 andalso wxListCtrl:refreshItems(Grid, Min, Max),
+    observer_wx:set_status(io_lib:format("Tables: ~w", [Max+1])),
+    {noreply, State};
+
+handle_info({selected, New, Size}, #state{grid=Grid, selected=Old} = State) ->
+    if
+        is_integer(Old), Old < Size ->
+            wxListCtrl:setItemState(Grid, Old, 0, ?wxLIST_STATE_SELECTED);
+        true -> ignore
+    end,
+    if is_integer(New) ->
+            wxListCtrl:setItemState(Grid, New, 16#FFFF, ?wxLIST_STATE_SELECTED),
+            wxListCtrl:ensureVisible(Grid, New);
+       true -> ignore
+    end,
+    {noreply, State#state{selected=New}};
 
 handle_info(_Event, State) ->
     {noreply, State}.
 
-terminate(_Event, _State) ->
+terminate(_Event, #state{holder=Holder}) ->
+    Holder ! stop,
     ok.
 
 code_change(_, _, State) ->
@@ -271,7 +287,7 @@ code_change(_, _, State) ->
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-create_menus(Parent, #opt{sys_hidden=Sys, unread_hidden=UnR, type=Type}) ->
+create_menus(Parent, #opts{sys_hidden=Sys, unread_hidden=UnR, type=Type}) ->
     MenuEntries = [{"View",
 		    [#create_menu{id = ?ID_TABLE_INFO, text = "Table information\tCtrl-I"},
 		     separator,
@@ -298,7 +314,7 @@ get_tables(Node, Opts) ->
 	Res ->
 	    Res
     end.
-get_tables2(Node, #opt{type=Type, sys_hidden=Sys, unread_hidden=Unread}) ->
+get_tables2(Node, #opts{type=Type, sys_hidden=Sys, unread_hidden=Unread}) ->
     Args = [Type, [{sys_hidden,Sys}, {unread_hidden,Unread}]],
     case rpc:call(Node, observer_backend, get_table_list, Args) of
 	{badrpc, Error} ->
@@ -386,49 +402,134 @@ list_to_strings([A]) -> integer_to_list(A);
 list_to_strings([A|B]) ->
     integer_to_list(A) ++ " ," ++ list_to_strings(B).
 
-update_grid(Grid, Selected, Opt, Tables) ->
-    wx:batch(fun() -> update_grid2(Grid, Selected, Opt, Tables) end).
-
-update_grid2(Grid, {SelName,SelId}, #opt{sort_key=Sort,sort_incr=Dir}, Tables) ->
-    wxListCtrl:deleteAllItems(Grid),
-    Update =
-	fun(#tab{name = Name, id = Id, owner = Owner, size = Size, memory = Memory,
-		 protection = Protection, reg_name = RegName},
-            {Row, Sel}) ->
-		_Item = wxListCtrl:insertItem(Grid, Row, ""),
-		if (Row rem 2) =:= 0 ->
-			wxListCtrl:setItemBackgroundColour(Grid, Row, ?BG_EVEN);
-		   true -> ignore
-		end,
-		if Protection == private ->
-			wxListCtrl:setItemTextColour(Grid, Row, {200,130,50});
-		   true -> ignore
-		end,
-
-		lists:foreach(fun({_, ignore}) -> ignore;
-				 ({Col, Val}) ->
-				      wxListCtrl:setItem(Grid, Row, Col, observer_lib:to_str(Val))
-			      end,
-			      [{0,Name}, {1,Size}, {2, Memory div 1024},
-			       {3,Owner}, {4,RegName}, {5,Id}]),
-                if SelName =:= Name, SelId =:= Id ->
-                        wxListCtrl:setItemState(Grid, Row, 16#FFFF, ?wxLIST_STATE_SELECTED),
-                        {Row+1, Row};
-                   true ->
-                        wxListCtrl:setItemState(Grid, Row, 0, ?wxLIST_STATE_SELECTED),
-                        {Row+1, Sel}
-                end
-	end,
-    ProcInfo = case Dir of
-		   false -> lists:reverse(lists:keysort(Sort, Tables));
-		   true -> lists:keysort(Sort, Tables)
-	       end,
-    {_, Sel} = lists:foldl(Update, {0, undefined}, ProcInfo),
-    {ProcInfo, Sel}.
-
-sel(#state{selected=Sel, tabs=Tabs}) ->
-    try lists:nth(Sel+1, Tabs) of
-        #tab{name=Name, id=Id} -> {Name, Id}
-    catch _:_ ->
-            {undefined, undefined}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%  Table holder needs to be in a separate process otherwise
+%%  the callback get_row/3 may deadlock if the process do
+%%  wx calls when callback is invoked.
+
+get_table(Table, Item) ->
+    get_row(Table, Item, all).
+
+get_row(Table, Item, Column) ->
+    Ref = erlang:monitor(process, Table),
+    Table ! {get_row, self(), Item, Column},
+    receive
+	{'DOWN', Ref, _, _, _} -> "";
+	{Table, Res} ->
+	    erlang:demonitor(Ref),
+	    Res
     end.
+
+get_attr(Table, Item) ->
+    Ref = erlang:monitor(process, Table),
+    Table ! {get_attr, self(), Item},
+    receive
+	{'DOWN', Ref, _, _, _} -> wx:null();
+	{Table, Res} ->
+	    erlang:demonitor(Ref),
+	    Res
+    end.
+
+-record(holder, {node, parent, pid,
+		 tabs=array:new(),
+                 sort=#sort{},
+		 attrs,
+                 sel
+		}).
+
+init_table_holder(Parent, Attrs) ->
+    Parent ! refresh,
+    table_holder(#holder{node=node(), parent=Parent, attrs=Attrs}).
+
+table_holder(S0 = #holder{parent=Parent, tabs=Tabs0, sel=Sel0}) ->
+    receive
+	{get_attr, From, Row} ->
+	    get_attr(From, Row, S0),
+	    table_holder(S0);
+	{get_row, From, Row, Col} ->
+	    get_row(From, Row, Col, Tabs0),
+	    table_holder(S0);
+	{sort, Col} ->
+            STab = get_sel(Sel0, Tabs0),
+	    Parent ! {refresh, 0, array:size(Tabs0)-1},
+            S1 = sort(col2key(Col), S0),
+            Sel = sel_idx(STab, S1#holder.tabs),
+            Parent ! {selected, Sel, array:size(Tabs0)},
+	    table_holder(S1#holder{sel=Sel});
+	{refresh, Tabs1} ->
+            STab = get_sel(Sel0, Tabs0),
+            Tabs = case S0#holder.sort of
+                       #sort{sort_incr=false, sort_key=Col} ->
+                           array:from_list(lists:reverse(lists:keysort(Col, Tabs1)));
+                       #sort{sort_key=Col} ->
+                           array:from_list(lists:keysort(Col, Tabs1))
+                   end,
+	    Parent ! {refresh, 0, array:size(Tabs)-1},
+            Sel = sel_idx(STab, Tabs),
+            Parent ! {selected, Sel,array:size(Tabs)},
+	    table_holder(S0#holder{tabs=Tabs, sel=Sel});
+        {selected, Sel} ->
+            table_holder(S0#holder{sel=Sel});
+	stop ->
+	    ok;
+	What ->
+	    io:format("Table holder got ~tp~n",[What]),
+	    Parent ! {refresh, 0, array:size(Tabs0)-1},
+	    table_holder(S0)
+    end.
+
+get_sel(undefined, _Tabs) ->
+    undefined;
+get_sel(Idx, Tabs) ->
+    array:get(Idx, Tabs).
+
+sel_idx(undefined, _Tabs) ->
+    undefined;
+sel_idx(Tab, Tabs) ->
+    Find = fun(Idx, C, Acc) -> C =:= Tab andalso throw({found, Idx}), Acc end,
+    try array:foldl(Find, undefined, Tabs)
+    catch {found, Idx} -> Idx
+    end.
+
+sort(Col, #holder{sort=#sort{sort_key=Col, sort_incr=Incr}=S, tabs=Table0}=H) ->
+    Table = lists:reverse(array:to_list(Table0)),
+    H#holder{sort=S#sort{sort_incr=(not Incr)},
+             tabs=array:from_list(Table)};
+sort(Col, #holder{sort=#sort{sort_incr=Incr}=S, tabs=Table0}=H) ->
+    Table = case Incr of
+                false -> lists:reverse(lists:keysort(Col, array:to_list(Table0)));
+                true -> lists:keysort(Col, array:to_list(Table0))
+            end,
+    H#holder{sort=S#sort{sort_key=Col},
+             tabs=array:from_list(Table)}.
+
+get_row(From, Row, Col, Table) ->
+    Object = array:get(Row, Table),
+    From ! {self(), get_col(Col, Object)}.
+
+get_col(all, Rec) ->
+    Rec;
+get_col(2, #tab{}=Rec) -> %% Memory in kB
+    observer_lib:to_str(element(#tab.memory, Rec) div 1024);
+get_col(Col, #tab{}=Rec) ->
+    case element(col2key(Col), Rec) of
+        ignore -> "";
+        Val -> observer_lib:to_str(Val)
+    end;
+get_col(_, _) ->
+    "".
+
+get_attr(From, Row, #holder{tabs=Tabs, attrs=Attrs}) ->
+    EvenOdd = case (Row rem 2) > 0 of
+                  true -> Attrs#attrs.odd;
+                  false -> Attrs#attrs.even
+              end,
+    What = try array:get(Row, Tabs) of
+               #tab{protection=private} ->
+                   Attrs#attrs.deleted;
+               _ ->
+                   EvenOdd
+           catch _ ->
+                   EvenOdd
+           end,
+    From ! {self(), What}.
diff --git a/lib/observer/test/observer_SUITE.erl b/lib/observer/test/observer_SUITE.erl
index 0db2c1ea77..fd4f93f662 100644
--- a/lib/observer/test/observer_SUITE.erl
+++ b/lib/observer/test/observer_SUITE.erl
@@ -113,7 +113,12 @@ appup_file(Config) when is_list(Config) ->
 basic(suite) -> [];
 basic(doc) -> [""];
 basic(Config) when is_list(Config) ->
-    timer:send_after(100, "foobar"), %% Otherwise the timer server gets added to procs
+    %% Start these before
+    wx:new(),
+    wx:destroy(),
+    timer:send_after(100, "foobar"),
+    {foo, node@machine} ! dummy_msg,  %% start distribution stuff
+    %% Otherwise ever lasting servers gets added to procs
     ProcsBefore = processes(),
     ProcInfoBefore = [{P,process_info(P)} || P <- ProcsBefore],
     NumProcsBefore = length(ProcsBefore),