Pyan

Exploit Benchmark

Jan 25th, 2021
1,461
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. -- "I hereby put all Lua/LuaJIT tests and benchmarks that I wrote under the public domain." Mike Pall
  2. -- https://github.com/LuaJIT/LuaJIT-test-cleanup
  3.  
  4. bit = bit32
  5.  
  6. local benchmarks = {
  7.     {
  8.         Name = "Array3d",
  9.         Func = function()
  10.             local function array_set(self, x, y, z, p)
  11.                 assert(x >= 0 and x < self.nx, "x outside PA")
  12.                 assert(y >= 0 and y < self.ny, "y outside PA")
  13.                 assert(z >= 0 and z < self.nz, "z outside PA")
  14.                 local pos = (z * self.ny + y) * self.nx + x
  15.                 local image = self.image
  16.                 if self.packed then
  17.                     local maxv = self.max_voltage
  18.                     if p > maxv then
  19.                         self.max_voltage = p * 2.0
  20.                     end
  21.                     local oldp = image[pos] or 0.0 -- Works with uninitialized table, too
  22.                     if oldp > maxv then
  23.                         p = p + maxv * 2.0
  24.                     end
  25.                     image[pos] = p
  26.                 else
  27.                     image[pos] = p
  28.                 end
  29.                 self.changed = true
  30.                 self.changed_recently = true
  31.             end
  32.  
  33.             local function array_points(self)
  34.                 local y, z = 0, 0
  35.                 return function(self, x)
  36.                     x = x + 1
  37.                     if x >= self.nx then
  38.                         x = 0
  39.                         y = y + 1
  40.                         if y >= self.ny then
  41.                             y = 0
  42.                             z = z + 1
  43.                             if z >= self.nz then
  44.                                 return nil, nil, nil
  45.                             end
  46.                         end
  47.                     end
  48.                     return x, y, z
  49.                 end, self, 0
  50.             end
  51.  
  52.             local function array_new(nx, ny, nz, packed)
  53.                 return {
  54.                     nx = nx,
  55.                     ny = ny,
  56.                     nz = nz,
  57.                     packed = packed,
  58.                     max_voltage = 0.0,
  59.                     changed = false,
  60.                     changed_recently = false,
  61.                     image = {}, -- Preferably use a fixed-type, pre-sized array here.
  62.                     set = array_set,
  63.                     points = array_points
  64.                 }
  65.             end
  66.  
  67.             local packed = true -- Packed image or flat
  68.  
  69.             local function run_iter(scaling)
  70.                 local dim = scaling -- Array dimension dim^3
  71.                 local arr = array_new(dim, dim, dim, packed)
  72.                 for x, y, z in arr:points() do
  73.                     arr:set(x, y, z, x * x)
  74.                 end
  75.                 assert(arr.image[dim ^ 3 - 1] == (dim - 1) ^ 2)
  76.             end
  77.  
  78.             return run_iter(200)
  79.         end
  80.     },
  81.     {
  82.         Name = "binarytrees",
  83.         Func = function()
  84.             local MIN_DEPTH = 4
  85.             local MAX_DEPTH = 12
  86.             local EXPECT_CKSUM = -10914
  87.  
  88.             local function BottomUpTree(item, depth)
  89.                 if depth > 0 then
  90.                     local i = item + item
  91.                     depth = depth - 1
  92.                     local left, right = BottomUpTree(i - 1, depth), BottomUpTree(i, depth)
  93.                     return {item, left, right}
  94.                 else
  95.                     return {item} -- Faster for LuaJIT: return { item, false }
  96.                 end
  97.             end
  98.  
  99.             local function ItemCheck(tree)
  100.                 if #tree == 3 then -- Faster for LuaJIT: if tree[2] then
  101.                     return tree[1] + ItemCheck(tree[2]) - ItemCheck(tree[3])
  102.                 else
  103.                     return tree[1]
  104.                 end
  105.             end
  106.  
  107.             local function inner_iter(mindepth, maxdepth)
  108.                 local check = 0
  109.  
  110.                 do
  111.                     local stretchdepth = maxdepth + 1
  112.                     local stretchtree = BottomUpTree(0, stretchdepth)
  113.                     check = check + ItemCheck(stretchtree)
  114.                 end
  115.  
  116.                 local longlivedtree = BottomUpTree(0, maxdepth)
  117.  
  118.                 for depth = mindepth, maxdepth, 2 do
  119.                     local iterations = 2 ^ (maxdepth - depth + mindepth)
  120.                     for i = 1, iterations do
  121.                         check = check + ItemCheck(BottomUpTree(1, depth)) + ItemCheck(BottomUpTree(-1, depth))
  122.                     end
  123.                 end
  124.  
  125.                 check = check + ItemCheck(longlivedtree)
  126.  
  127.                 if check ~= EXPECT_CKSUM then
  128.                     puts("bad checksum: " .. checksum .. " vs " .. EXPECT_CKSUM)
  129.                     os.exit(1)
  130.                 end
  131.             end
  132.  
  133.             local function run_iter(n)
  134.                 local i
  135.                 for i = 1, n do
  136.                     inner_iter(MIN_DEPTH, MAX_DEPTH)
  137.                 end
  138.             end
  139.  
  140.             return run_iter(3)
  141.         end
  142.     },
  143.     {
  144.         Name = "coroutines",
  145.         Func = function()
  146.             local poolsize = 503
  147.             local threads = {}
  148.  
  149.             -- cache these to avoid global environment lookups
  150.             local create = coroutine.create
  151.             local resume = coroutine.resume
  152.             local yield = coroutine.yield
  153.  
  154.             local id = 1
  155.             local token = 0
  156.             local ok
  157.  
  158.             local body = function(token)
  159.                 while true do
  160.                     token = yield(token + 1)
  161.                 end
  162.             end
  163.  
  164.             -- create all threads
  165.             for id = 1, poolsize do
  166.                 threads[id] = create(body)
  167.             end
  168.  
  169.             local function run_iter(n)
  170.                 id = 1
  171.                 token = 0
  172.  
  173.                 -- send the token
  174.                 repeat
  175.                     if id == poolsize then
  176.                         id = 1
  177.                     else
  178.                         id = id + 1
  179.                     end
  180.                     ok, token = resume(threads[id], token)
  181.                 until token == n
  182.             end
  183.  
  184.             return run_iter(3300000)
  185.         end
  186.     },
  187.     {
  188.         Name = "euler",
  189.         Func = function()
  190.             --if not bit then
  191.             --bit = require("bit")
  192.             --end
  193.  
  194.             local bnot, bor, band = bit.bnot, bit.bor, bit.band
  195.             local shl, shr = bit.lshift, bit.rshift
  196.  
  197.             function run_iter(N)
  198.                 local cache, m, n = {1}, 1, 1
  199.                 for i = 2, N do
  200.                     local j = i
  201.                     for len = 1, 1000000000 do
  202.                         j =
  203.                             bit32.bor(
  204.                             bit32.band(bit32.rshift(j, 1), bit32.band(j, 1) - 1),
  205.                             bit32.band(bit32.lshift(j, 1) + j + 1, bit32.bnot(bit32.band(j, 1) - 1))
  206.                         )
  207.                         if cache then
  208.                             local x = cache[j]
  209.                             if x then
  210.                                 j = x + len
  211.                                 break
  212.                             end
  213.                         elseif j == 1 then
  214.                             j = len + 1
  215.                             break
  216.                         end
  217.                     end
  218.                     if cache then
  219.                         cache[i] = j
  220.                     end
  221.                     if j > m then
  222.                         m, n = j, i
  223.                     end
  224.                 end
  225.                 assert(m > 1 and n > 1)
  226.             end
  227.  
  228.             return run_iter(3500000)
  229.         end
  230.     }
  231. }
  232.  
  233. local output = ""
  234.  
  235. output = output .. "[Robot Benchmarker]: Running benchmarks..." .. "\n"
  236.  
  237. local function getTime()
  238.     if tick then
  239.         return tick()
  240.     else
  241.         return os.clock()
  242.     end
  243. end
  244.  
  245. for _, v in pairs(benchmarks) do
  246.     local start = getTime()
  247.     output = output .. "    [+]: Running benchmark '" .. v.Name .. "'..." .. "\n"
  248.  
  249.     local v, msg =
  250.         pcall(
  251.         function()
  252.             v.Func()
  253.         end
  254.     )
  255.  
  256.     if not v then
  257.         output = output .. "    [+]: Benchmark failed, is your exploit shit?" .. "\n"
  258.     else
  259.         local endT = getTime()
  260.         output = output .. "    [+]: Benchmark finished in " .. (endT - start) .. "\n\n"
  261.     end
  262. end
  263.  
  264. print(output)
  265. setclipboard(output)
  266.  
RAW Paste Data