tcltk/tcltk2 的 R：使用 TkTable 显示大 data.frame 时改善缓慢的性能？
R with tcltk/tcltk2: Improve slow performance when displaying big data.frame with TkTable?
请参阅下面的两个编辑（稍后添加）...
我已经将一个大 data.frame 加载到内存中（2.7 mio 行和 7 列 - 74 MB RAM）。
如果我想通过tcltk2包函数tk2edit
使用Tcl/Tk的Tktable widget查看数据
- 超过 15 分钟 直到 window 显示数据
- 和大约 7 GB 的 RAM (!) 被 R（包括 Tcl/Tk）消耗了！
示例：
library(tcltk2)
my.data.frame <- data.frame(ID=1:2600000,
col1=rep(LETTERS,100000),
col2=rep(letters,1E5),
col3=26E5:1) # about 40 MB of data
tk2edit(my.data.frame)
基本问题似乎是 data.frame 的每个单元格都必须通过两个嵌套循环 () 加载到 tcl 数组中。
tcltk2 包的函数 tk2edit 以同样的方式工作，过度简化：
# my.data.frame contains a lot of rows...
for (i in 0:(dim(my.data.frame)[1])) {
for (j in 0:(dim(my.data.frame)[2]-1)) {
tclarray1[[i,j]] <- my.data.frame[i, j]
}
}
问题：有什么方法可以优化显示大 data.frames 与 tktable, e. G。通过避免嵌套循环？ 我只想查看数据（无需编辑）...
tktable 有 -variable 选项，您可以在其中设置包含 table 的所有数据的 tcl 数组变量。所以我们 "only" 必须找到方法从 R data.frame 和 "one call to tcl from R"...
创建一个 tcl 数组
PS：这不是 tcltk2 包的问题，但似乎是如何将 data.frame 的数据 "bulk load" 转换为 Tcl 变量的一般问题。 ..
PS2：好的是 Tktable 似乎能够有效地显示如此多的数据（我可以滚动甚至编辑单元格而不会注意到任何严重的延迟）。
编辑 1 (09/01/2015)：添加带有 Tktable 的纯 Tcl/Tk 基准测试结果和数组
中的数据
我在Tcl/Tk中准备了一个简单的基准测试来测量填充类似Tktable:
的执行时间和内存消耗
#!/usr/bin/env wish
package require Tktable
set rows 2700000
set columns 4
for {set row 0} {$row <= $rows} {incr row} {
for {set column 0} {$column < $columns} {incr column} {
if {$row == 0} {
set data($row,$column) Titel$column
} else {
set data($row,$column) R${row}C${column}
}
}
}
ttk::frame .fr
table .fr.table -rows $rows -cols $columns -titlerows 1 -titlecols 0 -height 5 -width 25 -rowheight 1 -colwidth 9 -maxheight 100 -maxwidth 400 -selectmode extended -variable data -xscrollcommand {.fr.xscroll set} -yscrollcommand {.fr.yscroll set}
scrollbar .fr.xscroll -command {.fr.table xview} -orient horizontal
scrollbar .fr.yscroll -command {.fr.table yview}
pack .fr -fill both -expand 1
pack .fr.xscroll -side bottom -fill x
pack .fr.yscroll -side right -fill y
pack .fr.table -side right -fill both -expand 1
结果：
- 内存消耗：3.2 GB
- 显示 table 的时间：15 秒。
结论： Tcl/Tk数组是在浪费内存，但是性能很好（用tcltk使用R时15分钟的runtime好像是R造成的Tcl/Tk 通信开销。
测试设置：Ubuntu 14.04 64 位，16 GB RAM...
编辑 2 (10/01/2015)：将 ttk::treeview 的纯 Tcl/Tk 基准测试结果添加到列表
中
为了比较 Tktable 和 ttk::treeview 的内存消耗，我写了这段代码：
#!/usr/bin/env wish
set rows 2700000
set columns 4
set data {}
set colnames {}
for {set i 0} {$i < $columns} {incr i} {
lappend colnames Title$i
}
for {set row 0} {$row <= $rows} {incr row} {
set newrow {}
for {set column 0} {$column < $columns} {incr column} {
lappend newrow R${row}C${column}
}
lappend data $newrow
}
ttk::treeview .tv -columns $colnames -show headings -yscrollcommand {.sbY set} -xscrollcommand {.sbX set}
foreach Element $data {
.tv insert {} end -values $Element
}
foreach column $colnames {
.tv heading $column -text $column
}
ttk::scrollbar .sbY -command {.tv yview}
ttk::scrollbar .sbX -command {.tv xview} -orient horizontal
pack .sbY -side right -fill y
pack .sbX -side bottom -fill x
pack .tv -side left -fill both
结果：
- 内存消耗：2GB（其中存储为列表的数据：1.2GB）
- 显示 table 的时间：15 秒。
- 比较：10 mio 行消耗 7.2 GB RAM 但选择一行需要几秒 (2 - 5) 然后（可能的原因：内部列表遍历？）
结论：
treeview 比 Tktable 的内存效率更高，因为它可以使用列表而不是数组。- 对于更大的数据大小（> 几百万行），行选择很慢（越到最后越慢！）
我找到了一种可能 solution/workaround 在 "unbound"（命令）模式下使用 Tktable。
使用 Tktable 的 command 选项，您可以指定每次在屏幕上显示单元格时调用的函数。这样就避免了"loading"一次把所有数据从R传给Tcl，提高了"start-up"的时间，显着减少了TCL存储数组和列表的方式带来的内存消耗。
这样每次滚动时都会进行一系列函数调用以询问可见单元格的内容。
即使超过 10 mio，它也适用于我。行！
缺点： 调用 R 函数 returns 每个单元格的 Tcl 变量仍然远非高效。如果您是第一次滚动，您可以看到正在更新的单元格。 因此我仍在寻找 R 和 Tcl/Tk 之间的批量数据传输解决方案。
欢迎提出任何改进性能的建议！
我实现了一个小演示（1 mio.行和 21 列消耗 1.2 GB RAM）并添加了一些按钮来测试不同的功能（如缓存）。
注意：start-up时间长是创建底层测试数据造成的，不是Tktable造成的！
library(tcltk)
library(data.table)
# Tktable example with -command ("unbound" mode) ---------------------------
# Doc: http://tktable.sourceforge.net/tktable/doc/tkTable.html
NUM.ROWS <- 1E6
NUM.COLS <- 20
# generate a big data.frame - this will take a while but is required for the demo
dt.data <- data.table(ID = 1:NUM.ROWS)
for (i in 1:NUM.COLS) {
dt.data[, (paste("Col",i)) := paste0("R", 1:NUM.ROWS, " C", i)]
}
# Fill one cell with a long text containing special control characters to test the Tktable behaviour
dt.data[3,3 := "This is a long text with backslash \ and \"quotes\"!"]
tclRequire("Tktable")
t <- tktoplevel()
tkwm.protocol(t, "WM_DELETE_WINDOW", function() tkdestroy(t))
# Function to return the current row and column as "calculated" value (without an underlying data "model")
calculated.data <- function(C) {
# Function arguments for Tcl "substitutions":
# See: http://tktable.sourceforge.net/tktable/doc/tkTable.html
# %c the column of the triggered cell.
# %C A convenience substitution for %r,%c.
# %i 0 for a read (get) and 1 for a write (set). Otherwise it is the current cursor position in the cell.
# %r the row of the triggered cell.
return(tclVar(C)) # this does work!
}
# Function to return the content of a data.table for the current row and colum
data.frame.data <- function(r, c) {
if( r == "0")
return(tclVar(names(dt.data)[as.integer(c)+1])) # First row contains the column names
else
return(tclVar(as.character(dt.data[as.integer(r)+1, as.integer(c)+1, with = FALSE]))) # Other rows are data rows
}
frame <- ttklabelframe(t, text = "Data:")
# Add the table to the window environment to ensure killing it when the window is closed (= no more phantom calls to the data command handler)
# Cache = TRUE: This greatly enhances speed performance when used with -command but uses extra memory.
t$env$table <- tkwidget(frame, "table", rows = NUM.ROWS, cols = NUM.COLS, titlerows = 1, selecttype = "cell", selectmode = "extended", command = calculated.data, cache = TRUE, yscrollcommand = function(...) tkset(scroll.y, ...), xscrollcommand = function(...) tkset(scroll.x, ...))
scroll.x <- ttkscrollbar(frame, orient = "horizontal", command=function(...) tkxview(t$env$table,...)) # command that performs the scrolling
scroll.y <- ttkscrollbar(frame, orient = "vertical", command=function(...) tkyview(t$env$table,...)) # command that performs the scrolling
buttons <- ttkframe(t)
btn.read.only <- ttkbutton(buttons, text = "make read only", command = function() tkconfigure(t$env$table, state = "disabled"))
btn.read.write <- ttkbutton(buttons, text = "make writable", command = function() tkconfigure(t$env$table, state = "normal"))
btn.clear.cache <- ttkbutton(buttons, text = "clear cache", command = function() tcl(t$env$table, "clear", "cache"))
btn.bind.data.frame <- ttkbutton(buttons, text = "Fill cells from R data.table",
command = function() {
tkconfigure(t$env$table, command = data.frame.data, rows = nrow(dt.data), cols = ncol(dt.data), titlerows = 1)
tcl(t$env$table, "clear", "cache")
tkwm.title(t,"Cells are filled from an R data.table")
})
btn.bind.calc.value <- ttkbutton(buttons, text = "Fill cells with calculated values",
command = function() {
tkconfigure(t$env$table, command = calculated.data, rows = 1E5, cols = 40)
tcl(t$env$table, "clear", "cache")
tkwm.title(t,"Cells are calculated values (to test the highest performance possible)")
})
tkgrid(btn.read.only, row = 0, column = 1)
tkgrid(btn.read.write, row = 0, column = 2)
tkgrid(btn.clear.cache, row = 0, column = 3)
tkgrid(btn.bind.data.frame, row = 0, column = 5)
tkgrid(btn.bind.calc.value, row = 0, column = 6)
tkpack(frame, fill = "both", expand = TRUE)
tkpack(scroll.x, fill = "x", expand = FALSE, side = "bottom")
tkpack(scroll.y, fill = "y", expand = FALSE, side = "right")
tkpack(t$env$table, fill = "both", expand = TRUE, side = "left")
tkpack(buttons, side = "bottom")
请参阅下面的两个编辑（稍后添加）...
我已经将一个大 data.frame 加载到内存中（2.7 mio 行和 7 列 - 74 MB RAM）。
如果我想通过tcltk2包函数tk2edit
- 超过 15 分钟 直到 window 显示数据
- 和大约 7 GB 的 RAM (!) 被 R（包括 Tcl/Tk）消耗了！
示例：
library(tcltk2)
my.data.frame <- data.frame(ID=1:2600000,
col1=rep(LETTERS,100000),
col2=rep(letters,1E5),
col3=26E5:1) # about 40 MB of data
tk2edit(my.data.frame)
基本问题似乎是 data.frame 的每个单元格都必须通过两个嵌套循环 (
tcltk2 包的函数 tk2edit 以同样的方式工作，过度简化：
# my.data.frame contains a lot of rows...
for (i in 0:(dim(my.data.frame)[1])) {
for (j in 0:(dim(my.data.frame)[2]-1)) {
tclarray1[[i,j]] <- my.data.frame[i, j]
}
}
问题：有什么方法可以优化显示大 data.frames 与 tktable, e. G。通过避免嵌套循环？ 我只想查看数据（无需编辑）...
tktable 有 -variable 选项，您可以在其中设置包含 table 的所有数据的 tcl 数组变量。所以我们 "only" 必须找到方法从 R data.frame 和 "one call to tcl from R"...
PS：这不是 tcltk2 包的问题，但似乎是如何将 data.frame 的数据 "bulk load" 转换为 Tcl 变量的一般问题。 ..
PS2：好的是 Tktable 似乎能够有效地显示如此多的数据（我可以滚动甚至编辑单元格而不会注意到任何严重的延迟）。
编辑 1 (09/01/2015)：添加带有 Tktable 的纯 Tcl/Tk 基准测试结果和数组
中的数据
我在Tcl/Tk中准备了一个简单的基准测试来测量填充类似Tktable:
#!/usr/bin/env wish
package require Tktable
set rows 2700000
set columns 4
for {set row 0} {$row <= $rows} {incr row} {
for {set column 0} {$column < $columns} {incr column} {
if {$row == 0} {
set data($row,$column) Titel$column
} else {
set data($row,$column) R${row}C${column}
}
}
}
ttk::frame .fr
table .fr.table -rows $rows -cols $columns -titlerows 1 -titlecols 0 -height 5 -width 25 -rowheight 1 -colwidth 9 -maxheight 100 -maxwidth 400 -selectmode extended -variable data -xscrollcommand {.fr.xscroll set} -yscrollcommand {.fr.yscroll set}
scrollbar .fr.xscroll -command {.fr.table xview} -orient horizontal
scrollbar .fr.yscroll -command {.fr.table yview}
pack .fr -fill both -expand 1
pack .fr.xscroll -side bottom -fill x
pack .fr.yscroll -side right -fill y
pack .fr.table -side right -fill both -expand 1
结果：
- 内存消耗：3.2 GB
- 显示 table 的时间：15 秒。
结论： Tcl/Tk数组是在浪费内存，但是性能很好（用tcltk使用R时15分钟的runtime好像是R造成的Tcl/Tk 通信开销。
测试设置：Ubuntu 14.04 64 位，16 GB RAM...
编辑 2 (10/01/2015)：将 ttk::treeview 的纯 Tcl/Tk 基准测试结果添加到列表
中为了比较 Tktable 和 ttk::treeview 的内存消耗，我写了这段代码：
#!/usr/bin/env wish
set rows 2700000
set columns 4
set data {}
set colnames {}
for {set i 0} {$i < $columns} {incr i} {
lappend colnames Title$i
}
for {set row 0} {$row <= $rows} {incr row} {
set newrow {}
for {set column 0} {$column < $columns} {incr column} {
lappend newrow R${row}C${column}
}
lappend data $newrow
}
ttk::treeview .tv -columns $colnames -show headings -yscrollcommand {.sbY set} -xscrollcommand {.sbX set}
foreach Element $data {
.tv insert {} end -values $Element
}
foreach column $colnames {
.tv heading $column -text $column
}
ttk::scrollbar .sbY -command {.tv yview}
ttk::scrollbar .sbX -command {.tv xview} -orient horizontal
pack .sbY -side right -fill y
pack .sbX -side bottom -fill x
pack .tv -side left -fill both
结果：
- 内存消耗：2GB（其中存储为列表的数据：1.2GB）
- 显示 table 的时间：15 秒。
- 比较：10 mio 行消耗 7.2 GB RAM 但选择一行需要几秒 (2 - 5) 然后（可能的原因：内部列表遍历？）
结论：
treeview比Tktable的内存效率更高，因为它可以使用列表而不是数组。- 对于更大的数据大小（> 几百万行），行选择很慢（越到最后越慢！）
我找到了一种可能 solution/workaround 在 "unbound"（命令）模式下使用 Tktable。
使用 Tktable 的 command 选项，您可以指定每次在屏幕上显示单元格时调用的函数。这样就避免了"loading"一次把所有数据从R传给Tcl，提高了"start-up"的时间，显着减少了TCL存储数组和列表的方式带来的内存消耗。
这样每次滚动时都会进行一系列函数调用以询问可见单元格的内容。
即使超过 10 mio，它也适用于我。行！
缺点： 调用 R 函数 returns 每个单元格的 Tcl 变量仍然远非高效。如果您是第一次滚动，您可以看到正在更新的单元格。 因此我仍在寻找 R 和 Tcl/Tk 之间的批量数据传输解决方案。
欢迎提出任何改进性能的建议！
我实现了一个小演示（1 mio.行和 21 列消耗 1.2 GB RAM）并添加了一些按钮来测试不同的功能（如缓存）。
注意：start-up时间长是创建底层测试数据造成的，不是Tktable造成的！
library(tcltk)
library(data.table)
# Tktable example with -command ("unbound" mode) ---------------------------
# Doc: http://tktable.sourceforge.net/tktable/doc/tkTable.html
NUM.ROWS <- 1E6
NUM.COLS <- 20
# generate a big data.frame - this will take a while but is required for the demo
dt.data <- data.table(ID = 1:NUM.ROWS)
for (i in 1:NUM.COLS) {
dt.data[, (paste("Col",i)) := paste0("R", 1:NUM.ROWS, " C", i)]
}
# Fill one cell with a long text containing special control characters to test the Tktable behaviour
dt.data[3,3 := "This is a long text with backslash \ and \"quotes\"!"]
tclRequire("Tktable")
t <- tktoplevel()
tkwm.protocol(t, "WM_DELETE_WINDOW", function() tkdestroy(t))
# Function to return the current row and column as "calculated" value (without an underlying data "model")
calculated.data <- function(C) {
# Function arguments for Tcl "substitutions":
# See: http://tktable.sourceforge.net/tktable/doc/tkTable.html
# %c the column of the triggered cell.
# %C A convenience substitution for %r,%c.
# %i 0 for a read (get) and 1 for a write (set). Otherwise it is the current cursor position in the cell.
# %r the row of the triggered cell.
return(tclVar(C)) # this does work!
}
# Function to return the content of a data.table for the current row and colum
data.frame.data <- function(r, c) {
if( r == "0")
return(tclVar(names(dt.data)[as.integer(c)+1])) # First row contains the column names
else
return(tclVar(as.character(dt.data[as.integer(r)+1, as.integer(c)+1, with = FALSE]))) # Other rows are data rows
}
frame <- ttklabelframe(t, text = "Data:")
# Add the table to the window environment to ensure killing it when the window is closed (= no more phantom calls to the data command handler)
# Cache = TRUE: This greatly enhances speed performance when used with -command but uses extra memory.
t$env$table <- tkwidget(frame, "table", rows = NUM.ROWS, cols = NUM.COLS, titlerows = 1, selecttype = "cell", selectmode = "extended", command = calculated.data, cache = TRUE, yscrollcommand = function(...) tkset(scroll.y, ...), xscrollcommand = function(...) tkset(scroll.x, ...))
scroll.x <- ttkscrollbar(frame, orient = "horizontal", command=function(...) tkxview(t$env$table,...)) # command that performs the scrolling
scroll.y <- ttkscrollbar(frame, orient = "vertical", command=function(...) tkyview(t$env$table,...)) # command that performs the scrolling
buttons <- ttkframe(t)
btn.read.only <- ttkbutton(buttons, text = "make read only", command = function() tkconfigure(t$env$table, state = "disabled"))
btn.read.write <- ttkbutton(buttons, text = "make writable", command = function() tkconfigure(t$env$table, state = "normal"))
btn.clear.cache <- ttkbutton(buttons, text = "clear cache", command = function() tcl(t$env$table, "clear", "cache"))
btn.bind.data.frame <- ttkbutton(buttons, text = "Fill cells from R data.table",
command = function() {
tkconfigure(t$env$table, command = data.frame.data, rows = nrow(dt.data), cols = ncol(dt.data), titlerows = 1)
tcl(t$env$table, "clear", "cache")
tkwm.title(t,"Cells are filled from an R data.table")
})
btn.bind.calc.value <- ttkbutton(buttons, text = "Fill cells with calculated values",
command = function() {
tkconfigure(t$env$table, command = calculated.data, rows = 1E5, cols = 40)
tcl(t$env$table, "clear", "cache")
tkwm.title(t,"Cells are calculated values (to test the highest performance possible)")
})
tkgrid(btn.read.only, row = 0, column = 1)
tkgrid(btn.read.write, row = 0, column = 2)
tkgrid(btn.clear.cache, row = 0, column = 3)
tkgrid(btn.bind.data.frame, row = 0, column = 5)
tkgrid(btn.bind.calc.value, row = 0, column = 6)
tkpack(frame, fill = "both", expand = TRUE)
tkpack(scroll.x, fill = "x", expand = FALSE, side = "bottom")
tkpack(scroll.y, fill = "y", expand = FALSE, side = "right")
tkpack(t$env$table, fill = "both", expand = TRUE, side = "left")
tkpack(buttons, side = "bottom")