Mercurial
comparison third_party/luajit/src/jit/v.lua @ 178:94705b5986b3
[ThirdParty] Added WRK and luajit for load testing.
| author | MrJuneJune <me@mrjunejune.com> |
|---|---|
| date | Thu, 22 Jan 2026 20:10:30 -0800 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 177:24fe8ff94056 | 178:94705b5986b3 |
|---|---|
| 1 ---------------------------------------------------------------------------- | |
| 2 -- Verbose mode of the LuaJIT compiler. | |
| 3 -- | |
| 4 -- Copyright (C) 2005-2023 Mike Pall. All rights reserved. | |
| 5 -- Released under the MIT license. See Copyright Notice in luajit.h | |
| 6 ---------------------------------------------------------------------------- | |
| 7 -- | |
| 8 -- This module shows verbose information about the progress of the | |
| 9 -- JIT compiler. It prints one line for each generated trace. This module | |
| 10 -- is useful to see which code has been compiled or where the compiler | |
| 11 -- punts and falls back to the interpreter. | |
| 12 -- | |
| 13 -- Example usage: | |
| 14 -- | |
| 15 -- luajit -jv -e "for i=1,1000 do for j=1,1000 do end end" | |
| 16 -- luajit -jv=myapp.out myapp.lua | |
| 17 -- | |
| 18 -- Default output is to stderr. To redirect the output to a file, pass a | |
| 19 -- filename as an argument (use '-' for stdout) or set the environment | |
| 20 -- variable LUAJIT_VERBOSEFILE. The file is overwritten every time the | |
| 21 -- module is started. | |
| 22 -- | |
| 23 -- The output from the first example should look like this: | |
| 24 -- | |
| 25 -- [TRACE 1 (command line):1 loop] | |
| 26 -- [TRACE 2 (1/3) (command line):1 -> 1] | |
| 27 -- | |
| 28 -- The first number in each line is the internal trace number. Next are | |
| 29 -- the file name ('(command line)') and the line number (':1') where the | |
| 30 -- trace has started. Side traces also show the parent trace number and | |
| 31 -- the exit number where they are attached to in parentheses ('(1/3)'). | |
| 32 -- An arrow at the end shows where the trace links to ('-> 1'), unless | |
| 33 -- it loops to itself. | |
| 34 -- | |
| 35 -- In this case the inner loop gets hot and is traced first, generating | |
| 36 -- a root trace. Then the last exit from the 1st trace gets hot, too, | |
| 37 -- and triggers generation of the 2nd trace. The side trace follows the | |
| 38 -- path along the outer loop and *around* the inner loop, back to its | |
| 39 -- start, and then links to the 1st trace. Yes, this may seem unusual, | |
| 40 -- if you know how traditional compilers work. Trace compilers are full | |
| 41 -- of surprises like this -- have fun! :-) | |
| 42 -- | |
| 43 -- Aborted traces are shown like this: | |
| 44 -- | |
| 45 -- [TRACE --- foo.lua:44 -- leaving loop in root trace at foo:lua:50] | |
| 46 -- | |
| 47 -- Don't worry -- trace aborts are quite common, even in programs which | |
| 48 -- can be fully compiled. The compiler may retry several times until it | |
| 49 -- finds a suitable trace. | |
| 50 -- | |
| 51 -- Of course this doesn't work with features that are not-yet-implemented | |
| 52 -- (NYI error messages). The VM simply falls back to the interpreter. This | |
| 53 -- may not matter at all if the particular trace is not very high up in | |
| 54 -- the CPU usage profile. Oh, and the interpreter is quite fast, too. | |
| 55 -- | |
| 56 -- Also check out the -jdump module, which prints all the gory details. | |
| 57 -- | |
| 58 ------------------------------------------------------------------------------ | |
| 59 | |
| 60 -- Cache some library functions and objects. | |
| 61 local jit = require("jit") | |
| 62 local jutil = require("jit.util") | |
| 63 local vmdef = require("jit.vmdef") | |
| 64 local funcinfo, traceinfo = jutil.funcinfo, jutil.traceinfo | |
| 65 local type, format = type, string.format | |
| 66 local stdout, stderr = io.stdout, io.stderr | |
| 67 | |
| 68 -- Active flag and output file handle. | |
| 69 local active, out | |
| 70 | |
| 71 ------------------------------------------------------------------------------ | |
| 72 | |
| 73 local startloc, startex | |
| 74 | |
| 75 local function fmtfunc(func, pc) | |
| 76 local fi = funcinfo(func, pc) | |
| 77 if fi.loc then | |
| 78 return fi.loc | |
| 79 elseif fi.ffid then | |
| 80 return vmdef.ffnames[fi.ffid] | |
| 81 elseif fi.addr then | |
| 82 return format("C:%x", fi.addr) | |
| 83 else | |
| 84 return "(?)" | |
| 85 end | |
| 86 end | |
| 87 | |
| 88 -- Format trace error message. | |
| 89 local function fmterr(err, info) | |
| 90 if type(err) == "number" then | |
| 91 if type(info) == "function" then info = fmtfunc(info) end | |
| 92 err = format(vmdef.traceerr[err], info) | |
| 93 end | |
| 94 return err | |
| 95 end | |
| 96 | |
| 97 -- Dump trace states. | |
| 98 local function dump_trace(what, tr, func, pc, otr, oex) | |
| 99 if what == "start" then | |
| 100 startloc = fmtfunc(func, pc) | |
| 101 startex = otr and "("..otr.."/"..(oex == -1 and "stitch" or oex)..") " or "" | |
| 102 else | |
| 103 if what == "abort" then | |
| 104 local loc = fmtfunc(func, pc) | |
| 105 if loc ~= startloc then | |
| 106 out:write(format("[TRACE --- %s%s -- %s at %s]\n", | |
| 107 startex, startloc, fmterr(otr, oex), loc)) | |
| 108 else | |
| 109 out:write(format("[TRACE --- %s%s -- %s]\n", | |
| 110 startex, startloc, fmterr(otr, oex))) | |
| 111 end | |
| 112 elseif what == "stop" then | |
| 113 local info = traceinfo(tr) | |
| 114 local link, ltype = info.link, info.linktype | |
| 115 if ltype == "interpreter" then | |
| 116 out:write(format("[TRACE %3s %s%s -- fallback to interpreter]\n", | |
| 117 tr, startex, startloc)) | |
| 118 elseif ltype == "stitch" then | |
| 119 out:write(format("[TRACE %3s %s%s %s %s]\n", | |
| 120 tr, startex, startloc, ltype, fmtfunc(func, pc))) | |
| 121 elseif link == tr or link == 0 then | |
| 122 out:write(format("[TRACE %3s %s%s %s]\n", | |
| 123 tr, startex, startloc, ltype)) | |
| 124 elseif ltype == "root" then | |
| 125 out:write(format("[TRACE %3s %s%s -> %d]\n", | |
| 126 tr, startex, startloc, link)) | |
| 127 else | |
| 128 out:write(format("[TRACE %3s %s%s -> %d %s]\n", | |
| 129 tr, startex, startloc, link, ltype)) | |
| 130 end | |
| 131 else | |
| 132 out:write(format("[TRACE %s]\n", what)) | |
| 133 end | |
| 134 out:flush() | |
| 135 end | |
| 136 end | |
| 137 | |
| 138 ------------------------------------------------------------------------------ | |
| 139 | |
| 140 -- Detach dump handlers. | |
| 141 local function dumpoff() | |
| 142 if active then | |
| 143 active = false | |
| 144 jit.attach(dump_trace) | |
| 145 if out and out ~= stdout and out ~= stderr then out:close() end | |
| 146 out = nil | |
| 147 end | |
| 148 end | |
| 149 | |
| 150 -- Open the output file and attach dump handlers. | |
| 151 local function dumpon(outfile) | |
| 152 if active then dumpoff() end | |
| 153 if not outfile then outfile = os.getenv("LUAJIT_VERBOSEFILE") end | |
| 154 if outfile then | |
| 155 out = outfile == "-" and stdout or assert(io.open(outfile, "w")) | |
| 156 else | |
| 157 out = stderr | |
| 158 end | |
| 159 jit.attach(dump_trace, "trace") | |
| 160 active = true | |
| 161 end | |
| 162 | |
| 163 -- Public module functions. | |
| 164 return { | |
| 165 on = dumpon, | |
| 166 off = dumpoff, | |
| 167 start = dumpon -- For -j command line option. | |
| 168 } | |
| 169 |