7332880272

Committed 26 Dec 2023 09:51PM UTC coverage: 43.517% (+0.1%) from 43.39%

Build # 7332880272

Build Type

Pull #458

github

Committed by

web-flow

Commit Message

Merge a8aabb23b into 88f4fe610

Pull Request Pull Request #458: Add hermes-specific support for the trace event format

Run Details

1179 of 2803 branches covered (0.0%)

Branch coverage included in aggregate %.

25 of 25 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

2691 of 6090 relevant lines covered (44.19%)

4028.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.68

/src/lib/lru-cache.ts

class ListNode<V> {
  prev: ListNode<V> | null = null
  next: ListNode<V> | null = null
  constructor(readonly data: V) {}
}

export class List<V> {
  private head: ListNode<V> | null = null
  private tail: ListNode<V> | null = null
  private size: number = 0
  constructor() {}

  getHead(): ListNode<V> | null {
    return this.head
  }
  getTail(): ListNode<V> | null {
    return this.tail
  }
  getSize(): number {
    return this.size
  }

  append(node: ListNode<V>): void {
    if (!this.tail) {
      this.head = this.tail = node
    } else {
      this.tail.next = node
      node.prev = this.tail
      this.tail = node
    }
    this.size++
  }

  prepend(node: ListNode<V>): ListNode<V> {
    if (!this.head) {
      this.head = this.tail = node
    } else {
      this.head.prev = node
      node.next = this.head
      this.head = node
    }
    this.size++
    return node
  }

  pop(): ListNode<V> | null {
    if (!this.tail) {
      return null
    } else {
      const ret = this.tail
      if (ret.prev) {
        this.tail = ret.prev
        this.tail.next = null
      } else {
        this.head = this.tail = null
      }
      this.size--
      ret.prev = null
      return ret
    }
  }

  dequeue(): ListNode<V> | null {
    if (!this.head) {
      return null
    } else {
      const ret = this.head
      if (ret.next) {
        this.head = ret.next
        this.head.prev = null
      } else {
        this.head = this.tail = null
      }
      this.size--
      ret.next = null
      return ret
    }
  }

  remove(node: ListNode<V>): void {
    if (node.prev == null) {
      this.dequeue()
    } else if (node.next == null) {
      this.pop()
    } else {
      // Neither first nor last, should be safe to just link
      // neighbours.
      node.next.prev = node.prev
      node.prev.next = node.next
      node.next = null
      node.prev = null
      this.size--
    }
  }
}

interface LRUCacheNode<K, V> {
  value: V
  listNode: ListNode<K>
}

export class LRUCache<K, V> {
  private list = new List<K>()
  private map = new Map<K, LRUCacheNode<K, V>>()

  constructor(private capacity: number) {}

  has(key: K): boolean {
    return this.map.has(key)
  }

  get(key: K): V | null {
    const node = this.map.get(key)
    if (!node) {
      return null
    }
    // Bring node to the front of the list
    this.list.remove(node.listNode)
    this.list.prepend(node.listNode)

    return node ? node.value : null
  }

  getSize() {
    return this.list.getSize()
  }

  getCapacity() {
    return this.capacity
  }

  insert(key: K, value: V) {
    const node = this.map.get(key)
    if (node) {
      this.list.remove(node.listNode)
    }
    // Evict old entries when out of capacity
    while (this.list.getSize() >= this.capacity) {
      this.map.delete(this.list.pop()!.data)
    }
    const listNode = this.list.prepend(new ListNode(key))
    this.map.set(key, {value, listNode})
  }

  getOrInsert(key: K, f: (key: K) => V): V {
    let value = this.get(key)
    if (value == null) {
      value = f(key)
      this.insert(key, value)
    }
    return value
  }

  removeLRU(): [K, V] | null {
    const oldest = this.list.pop()
    if (!oldest) return null
    const key = oldest.data
    const value = this.map.get(key)!.value
    this.map.delete(key)
    return [key, value]
  }

  clear() {
    this.list = new List<K>()
    this.map = new Map<K, LRUCacheNode<K, V>>()
  }
}

1	class ListNode<V> {
2	prev: ListNode<V> \| null = null	1,989✔
3	next: ListNode<V> \| null = null	1,989✔
4	constructor(readonly data: V) {}	1,989✔
5	}
6
7	export class List<V> {	2✔
8	private head: ListNode<V> \| null = null	2,002✔
9	private tail: ListNode<V> \| null = null	2,002✔
10	private size: number = 0	2,002✔
11	constructor() {}
12
13	getHead(): ListNode<V> \| null {
14	return this.head	×
15	}
16	getTail(): ListNode<V> \| null {
17	return this.tail	×
18	}
19	getSize(): number {
20	return this.size	3,025✔
21	}
22
23	append(node: ListNode<V>): void {
24	if (!this.tail) {	×
25	this.head = this.tail = node	×
26	} else {
27	this.tail.next = node	×
28	node.prev = this.tail	×
29	this.tail = node	×
30	}
31	this.size++	×
32	}
33
34	prepend(node: ListNode<V>): ListNode<V> {
35	if (!this.head) {	2,127✔
36	this.head = this.tail = node	1,514✔
37	} else {
38	this.head.prev = node	613✔
39	node.next = this.head	613✔
40	this.head = node	613✔
41	}
42	this.size++	2,127✔
43	return node	2,127✔
44	}
45
46	pop(): ListNode<V> \| null {
47	if (!this.tail) {	1,094✔
48	return null	701✔
49	} else {
50	const ret = this.tail	393✔
51	if (ret.prev) {	393✔
52	this.tail = ret.prev	115✔
53	this.tail.next = null	115✔
54	} else {
55	this.head = this.tail = null	278✔
56	}
57	this.size--	393✔
58	ret.prev = null	393✔
59	return ret	393✔
60	}
61	}
62
63	dequeue(): ListNode<V> \| null {
64	if (!this.head) {	168!
65	return null	×
66	} else {
67	const ret = this.head	168✔
68	if (ret.next) {	168✔
69	this.head = ret.next	30✔
70	this.head.prev = null	30✔
71	} else {
72	this.head = this.tail = null	138✔
73	}
74	this.size--	168✔
75	ret.next = null	168✔
76	return ret	168✔
77	}
78	}
79
80	remove(node: ListNode<V>): void {
81	if (node.prev == null) {	202✔
82	this.dequeue()	168✔
83	} else if (node.next == null) {	34✔
84	this.pop()	32✔
85	} else {
86	// Neither first nor last, should be safe to just link
87	// neighbours.
88	node.next.prev = node.prev	2✔
89	node.prev.next = node.next	2✔
90	node.next = null	2✔
91	node.prev = null	2✔
92	this.size--	2✔
93	}
94	}
95	}
96
97	interface LRUCacheNode<K, V> {
98	value: V
99	listNode: ListNode<K>
100	}
101
102	export class LRUCache<K, V> {	2✔
103	private list = new List<K>()	2,002✔
104	private map = new Map<K, LRUCacheNode<K, V>>()	2,002✔
105
106	constructor(private capacity: number) {}	2,002✔
107
108	has(key: K): boolean {
109	return this.map.has(key)	1,022✔
110	}
111
112	get(key: K): V \| null {
113	const node = this.map.get(key)	2,051✔
114	if (!node) {	2,051✔
115	return null	1,913✔
116	}
117	// Bring node to the front of the list
118	this.list.remove(node.listNode)	138✔
119	this.list.prepend(node.listNode)	138✔
120
121	return node ? node.value : null	138!
122	}
123
124	getSize() {
125	return this.list.getSize()	1,036✔
126	}
127
128	getCapacity() {
129	return this.capacity	×
130	}
131
132	insert(key: K, value: V) {
133	const node = this.map.get(key)	1,989✔
134	if (node) {	1,989✔
135	this.list.remove(node.listNode)	64✔
136	}
137	// Evict old entries when out of capacity
138	while (this.list.getSize() >= this.capacity) {	1,989✔
UNCOV 139	this.map.delete(this.list.pop()!.data)	×
140	}
141	const listNode = this.list.prepend(new ListNode(key))	1,989✔
142	this.map.set(key, {value, listNode})	1,989✔
143	}
144
145	getOrInsert(key: K, f: (key: K) => V): V {
146	let value = this.get(key)	1,024✔
147	if (value == null) {	1,024✔
148	value = f(key)	951✔
149	this.insert(key, value)	951✔
150	}
151	return value	1,024✔
152	}
153
154	removeLRU(): [K, V] \| null {
155	const oldest = this.list.pop()	1,062✔
156	if (!oldest) return null	1,062✔
157	const key = oldest.data	361✔
158	const value = this.map.get(key)!.value	361✔
159	this.map.delete(key)	361✔
160	return [key, value]	361✔
161	}
162
163	clear() {
164	this.list = new List<K>()	×
165	this.map = new Map<K, LRUCacheNode<K, V>>()	×
166	}
167	}

jlfwong / speedscope / 7332880272

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous