summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/tex/context/base/trac-tim.lua
blob: de7ceca4610f473bea3f3aac13ffba0740b4f842 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
if not modules then modules = { } end modules ['trac-tim'] = {
    version   = 1.001,
    comment   = "companion to m-timing.tex",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files"
}

local format, gsub = string.format, string.gsub
local concat, sort = table.concat, table.sort
local next, tonumber = next, tonumber

moduledata          = moduledata or { }
moduledata.progress = moduledata.progress or { }
local progress      = moduledata.progress

progress.defaultfilename = ((tex and tex.jobname) or "whatever") .. "-luatex-progress"

local params = {
    "cs_count",
    "dyn_used",
    "elapsed_time",
    "luabytecode_bytes",
    "luastate_bytes",
    "max_buf_stack",
    "obj_ptr",
    "pdf_mem_ptr",
    "pdf_mem_size",
    "pdf_os_cntr",
--  "pool_ptr", -- obsolete
    "str_ptr",
}

-- storage

local last  = os.clock()
local data  = { }

function progress.save(name)
    io.savedata((name or progress.defaultfilename) .. ".lut",table.serialize(data,true))
    data = { }
end

function progress.store()
    local c = os.clock()
    local t = {
        elapsed_time = c - last,
        node_memory  = nodes.pool.usage(),
    }
    for k, v in next, params do
        if status[v] then t[v] = status[v] end
    end
    data[#data+1] = t
    last = c
end

-- conversion

local processed = { }

local function convert(name)
    name = ((name ~= "") and name) or progress.defaultfilename
    if not processed[name] then
        local names, top, bot, pages, paths, keys = { }, { }, { }, 0, { }, { }
        local data = io.loaddata(name .. ".lut")
        if data then data = loadstring(data) end
        if data then data = data() end
        if data then
            pages = #data
            if pages > 1 then
                local factor = 100
                for k=1,#data do
                    for k, v in next, data[k].node_memory do
                        keys[k] = true
                    end
                end
                for k=1,#data do
                    local m = data[k].node_memory
                    for k, v in next, keys do
                        if not m[k] then m[k] = 0 end
                    end
                end
                local function path(tag,subtag)
                    local b, t, s = nil, nil, { }
                    for k=1,#data do
                        local v = data[k][tag]
                        v = v and (subtag and v[subtag]) or v
                        if v then
                            v = tonumber(v)
                            if b then
                                if v > t then t = v end
                                if v < b then b = v end
                            else
                                t = v
                                b = v
                            end
                            s[k] = v
                        else
                            s[k] = 0
                        end
                    end
                    local tagname = subtag or tag
                    top[tagname] = gsub(format("%.3f",t),"%.000$","")
                    bot[tagname] = gsub(format("%.3f",b),"%.000$","")
                    local delta = t-b
                    if delta == 0 then
                        delta = 1
                    else
                        delta = factor/delta
                    end
                    for k=1,#s do
                        s[k] = "(" .. k .. "," .. (s[k]-b)*delta .. ")"
                    end
                    paths[tagname] = concat(s,"--")
                end
                for _, tag in next, params do
                    path(tag)
                end
                for tag, _ in next, keys do
                    path("node_memory",tag)
                    names[#names+1] = tag
                end
                pages = pages - 1
            end
        end
        sort(names)
        processed[name] = {
            names = names,
            top   = top,
            bot   = bot,
            pages = pages,
            paths = paths,
        }
    end
    return processed[name]
end

progress.convert = convert

function progress.bot(name,tag)
    return convert(name).bot[tag] or 0
end

function progress.top(name,tag)
    return convert(name).top[tag] or 0
end

function progress.pages(name,tag)
    return convert(name).pages or 0
end

function progress.path(name,tag)
    return convert(name).paths[tag] or "origin"
end

function progress.nodes(name)
    return convert(name).names or { }
end

function progress.parameters(name)
    return params -- shared
end