lamb/test/benchmark.gleam at 9b9b0e2593213f0f94a0950a1193a810a57f1f1b · chouzar/lamb · GitHub

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
import artifacts/user
import gleam/erlang/process
import gleam/int
import gleam/io
import gleam/yielder
import gleam/list
import lamb
import lamb/query
import lamb/query/term

pub fn main() {
  // process.sleep(1000)
  // io.println("Index Table Benchmark:")
  // let table = initialize_indexed_table(500_000, lamb.Set)
  // run_indexed_benchmark(table)

  process.sleep(1000)
  io.println("Bag Table Benchmark:")
  let table = initialize_bagged_table(50_000)
  run_bagged_benchmark(table)
}

fn initialize_indexed_table(
  quantity: Int,
  kind: lamb.Kind,
) -> lamb.Table(Int, user.User) {
  let assert Ok(table) =
    lamb.create(
      name: "users",
      access: lamb.Protected,
      kind: kind,
      registered: False,
    )

  let enums =
    yielder.from_list([0, 1, 2])
    |> yielder.cycle()

  let ids = yielder.range(1, quantity)

  yielder.map2(enums, ids, fn(enum, id) { #(id, enum) })
  |> yielder.each(fn(params) {
    lamb.insert(table, params.0, user.generate(params.1))
  })

  table
}

fn initialize_bagged_table(
  records quantity: Int,
) -> lamb.Table(Group, user.User) {
  let assert Ok(table) =
    lamb.create(
      name: "users",
      access: lamb.Protected,
      kind: lamb.Bag,
      registered: False,
    )

  let enums =
    yielder.from_list([0, 1, 2])
    |> yielder.cycle()

  let ids = yielder.range(1, quantity)

  yielder.map2(enums, ids, fn(enum, id) { #(id, enum) })
  |> yielder.each(fn(params) {
    let assert [group, ..] = list.shuffle([GroupA, GroupB, GroupC])
    lamb.insert(table, group, user.generate(params.1))
  })

  lamb.insert(table, GroupD, user.generate(0))
  lamb.insert(table, GroupD, user.generate(1))
  lamb.insert(table, GroupD, user.generate(2))

  table
}

pub type Group {
  GroupA
  GroupB
  GroupC
  GroupD
}

pub fn query_find_record(index: index) {
  query.new()
  |> query.index(index)
  |> query.record(term.var(1))
  |> query.map(fn(_, _) { term.var(1) })
}

@external(erlang, "Elixir.Lamb.Artifacts.IndexedBenchmark", "run")
fn run_indexed_benchmark(table: lamb.Table(Int, user.User)) -> x

@external(erlang, "Elixir.Lamb.Artifacts.BaggedBenchmark", "run")
fn run_bagged_benchmark(table: lamb.Table(Group, user.User)) -> x

fn dbg(x: x) -> x {
  let _ = ffi_display(x)
  x
}

pub fn random(x: Int) -> Int {
  int.random(x)
}

@external(erlang, "erlang", "display")
fn ffi_display(x: x) -> y