From 13e8296c9ef9fe00731446f74391854c7910d3c5 Mon Sep 17 00:00:00 2001 From: Alexander Dovhal Date: Sun, 28 Sep 2025 15:09:58 +0000 Subject: [PATCH] Fixed Vlang examples to support 0.4.12. Added lru/3.v --- bench/algorithm/fasta/1.v | 13 ++-- bench/algorithm/lru/3.v | 132 +++++++++++++++++++++++++++++++++++ bench/algorithm/pidigits/2.v | 4 +- 3 files changed, 141 insertions(+), 8 deletions(-) create mode 100644 bench/algorithm/lru/3.v diff --git a/bench/algorithm/fasta/1.v b/bench/algorithm/fasta/1.v index c0f835937..18e880862 100644 --- a/bench/algorithm/fasta/1.v +++ b/bench/algorithm/fasta/1.v @@ -20,6 +20,9 @@ fn main() { n = strconv.atoi(os.args[1]) or { 1 } } + mut iobuf := []u8 { len: 32*1024} + C.setvbuf(C.stdout, iobuf.data, C._IOFBF, iobuf.len) + mut rand := RandGen{ seed: 42 } @@ -58,10 +61,8 @@ fn make_repeat_fasta(id string, desc string, src []byte, n int) { println('>${id} ${desc}') mut char_print_idx := 0 mut sb := strings.new_builder(line_width) - unsafe { - defer { - sb.free() - } + defer { + unsafe { sb.free() } } for _ in 0 .. (n / src.len + 1) { for c in src { @@ -92,8 +93,8 @@ fn make_random_fasta(mut rand_gen RandGen, id string, desc string, mut table map mut n_char_printed := 0 mut sb := strings.new_builder(line_width) - unsafe { - defer { + defer { + unsafe { sb.free() } } diff --git a/bench/algorithm/lru/3.v b/bench/algorithm/lru/3.v new file mode 100644 index 000000000..b944bfd06 --- /dev/null +++ b/bench/algorithm/lru/3.v @@ -0,0 +1,132 @@ +module main + +import os +import strconv + +const a = u32(1103515245) +const c = u32(12345) +const m = u32(1) << 31 + + +struct LCG { +mut: + seed u32 +} + +fn (mut lcg LCG) next() u32 { + lcg.seed = (a * lcg.seed + c) % m + return lcg.seed +} + + +struct Pair[K,V] { +mut: + k K + v V +} + +struct ListNode[K,V] { +mut: + data Pair[K,V] + next &ListNode[K,V] = unsafe{nil} + prev &ListNode[K,V] = unsafe{nil} +} + +struct LinkedList[K,V] { +mut: + head &ListNode[K,V] = unsafe { nil } + tail &ListNode[K,V] = unsafe { nil } + len int +} + +struct LRU[K,V] { + size int +mut: + keys map[K] &ListNode[K,V] + entries LinkedList[K,V] +} + + +fn (mut list LinkedList[K,V]) add(data Pair[K,V]) &ListNode[K,V] { + mut node := &ListNode[K,V]{ data: data } + list.add_node(mut *node) + list.len += 1 + return node +} + + +fn (mut list LinkedList[K,V]) add_node(mut node ListNode[K,V]) { + mut tail := list.tail + if list.head == unsafe { nil } { list.head = node } + else if tail != unsafe { nil } { + node.prev = tail + tail.next = node + } + list.tail = node + node.next = unsafe{ nil } +} + + +fn (mut list LinkedList[K,V]) remove(mut node ListNode[K,V]) { + if list.head == node { list.head = node.next } + if list.tail == node { list.tail = node.prev } + if node.prev != unsafe { nil } { node.prev.next = node.next } + if node.next != unsafe { nil } { node.next.prev = node.prev } +} + + +fn (mut list LinkedList[K,V]) move_to_end(mut node ListNode[K,V]) { + list.remove(mut *node) + list.add_node(mut *node) +} + + +fn (mut lru LRU[K, V]) get(key K) &V { + mut node := lru.keys[key] or { return unsafe{ nil } } + lru.entries.move_to_end(mut node) + return &node.data.v +} + + +fn (mut lru LRU[K, V]) put(key K, value V) { + mut node := lru.keys[key] or { + if lru.entries.len == lru.size { + mut head := lru.entries.head + lru.keys.delete(head.data.k) + head.data.k = key; head.data.v = value + lru.keys[key] = head + lru.entries.move_to_end(mut head) + return + } + lru.keys[key] = lru.entries.add(Pair[K, V] { k: key, v: value }) + return + } + node.data.v = value + lru.entries.move_to_end(mut node) +} + + +fn main() { + mut size := 100 + if os.args.len > 1 { size = strconv.atoi(os.args[1]) or { size } } + + mut n := 100 + if os.args.len > 2 { n = strconv.atoi(os.args[2]) or { n } } + mod := u32(size) * 10 + + mut rng0 := LCG{ seed: 0 } + mut rng1 := LCG{ seed: 1 } + mut lru := LRU[u32, u32] { size: size, keys : {}, entries: LinkedList[u32, u32]{} } + + mut hit := 0 + mut missed := 0 + + for _ in 0 .. n { + n0 := rng0.next() % mod + lru.put(n0, n0) + n1 := rng1.next() % mod + if lru.get(n1) != unsafe{ nil } { hit += 1 } + else { missed += 1 } + } + println('${hit}\n${missed}') +} diff --git a/bench/algorithm/pidigits/2.v b/bench/algorithm/pidigits/2.v index 51b74780b..ff3bb5db2 100644 --- a/bench/algorithm/pidigits/2.v +++ b/bench/algorithm/pidigits/2.v @@ -29,8 +29,8 @@ fn main() { mut w := zero mut sb := strings.new_builder(12 + n.str().len) - unsafe { - defer { + defer { + unsafe { sb.free() } }