Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

use Nat64 for PRNG #69

Merged
merged 8 commits into from
Jul 24, 2023
Merged

use Nat64 for PRNG #69

Show file tree
Hide file tree
Changes from 6 commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
3c80da4
use Nat32 for PRNG
chenyan-dfinity Jul 22, 2023
18e9e1e
fix
chenyan-dfinity Jul 22, 2023
87a12b9
fix
chenyan-dfinity Jul 22, 2023
e122cef
avoid debug_show overhead
chenyan-dfinity Jul 22, 2023
89cf0d5
use Nat64
chenyan-dfinity Jul 22, 2023
4fe8a4e
reuse rand for remove
chenyan-dfinity Jul 23, 2023
c6278af
scale collection to 1M (#70)
chenyan-dfinity Jul 24, 2023
9388b89
Merge branch 'main' into fix-random
chenyan-dfinity Jul 24, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
37 changes: 12 additions & 25 deletions collections/motoko/src/ZhenyaHashmap.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,52 +1,39 @@
import HashMap "mo:stable-hash-map";
import Nat32 "mo:base/Nat32";
import { hashNat8 } "mo:base/Hash";
import Nat64 "mo:base/Nat64";
import Hash "mo:base/Hash";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";

actor {
func f_hash(x : Nat32) : Nat32 = hashNat8([
x & (255 << 0),
x & (255 << 8),
x & (255 << 16),
x & (255 << 24),
]);
let hash : HashMap.HashUtils<Nat32> = (f_hash, Nat32.equal, func() = 0);
stable var map = HashMap.new<Nat32, Text>(hash);
func f_hash(x : Nat64) : Nat32 = Hash.hash(Nat64.toNat x);
let hash : HashMap.HashUtils<Nat64> = (f_hash, Nat64.equal, func() = 0);
stable var map = HashMap.new<Nat64, Nat64>(hash);
let rand = Random.new(null, 42);

public func generate(size : Nat) : async () {
public func generate(size : Nat32) : async () {
let rand = Random.new(?size, 1);
let iter = Iter.map<Nat32, (Nat32, Text)>(rand, func x = (x, debug_show x));
let iter = Iter.map<Nat64, (Nat64, Nat64)>(rand, func x = (x, x));
map := HashMap.fromIter(iter, hash);
};
public func get(x : Nat32) : async ?Text {
HashMap.get(map, hash, x);
};
public func put(k : Nat32, v : Text) : async () {
ignore HashMap.put(map, hash, k, v);
};
public func remove(x : Nat32) : async ?Text {
HashMap.remove(map, hash, x);
};
public query func get_mem() : async (Nat, Nat, Nat) {
Random.get_memory();
};
public func batch_get(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
ignore HashMap.get(map, hash, Option.get<Nat32>(rand.next(), 0));
ignore HashMap.get(map, hash, Option.get<Nat64>(rand.next(), 0));
};
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
ignore HashMap.put(map, hash, k, debug_show k);
let k = Option.get<Nat64>(rand.next(), 0);
ignore HashMap.put(map, hash, k, k);
};
};
public func batch_remove(n : Nat) : async () {
let rand = Random.new(null, 1);
for (_ in Iter.range(1, n)) {
ignore HashMap.remove(map, hash, Option.get<Nat32>(rand.next(), 0));
ignore HashMap.remove(map, hash, Option.get<Nat64>(rand.next(), 0));
};
};
};
32 changes: 12 additions & 20 deletions collections/motoko/src/btreemap.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,48 +1,40 @@
import Map "mo:stableheapbtreemap/BTree";
import Nat32 "mo:base/Nat32";
import Nat64 "mo:base/Nat64";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";

actor {
stable var map = Map.init<Nat32, Text>(null);
stable var map = Map.init<Nat64, Nat64>(null);
let rand = Random.new(null, 42);

public func generate(size : Nat) : async () {
public func generate(size : Nat32) : async () {
let rand = Random.new(?size, 1);
let iter = Iter.map<Nat32, (Nat32, Text)>(rand, func x = (x, debug_show x));
let iter = Iter.map<Nat64, (Nat64, Nat64)>(rand, func x = (x, x));
for ((k, v) in iter) {
ignore Map.insert(map, Nat32.compare, k, v);
ignore Map.insert(map, Nat64.compare, k, v);
};
};
public func get(x : Nat32) : async ?Text {
Map.get(map, Nat32.compare, x);
};
public func put(k : Nat32, v : Text) : async () {
ignore Map.insert(map, Nat32.compare, k, v);
};
public func remove(x : Nat32) : async ?Text {
Map.delete(map, Nat32.compare, x);
};
public query func get_mem() : async (Nat, Nat, Nat) {
Random.get_memory();
};
public func batch_get(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let x = Option.get<Nat32>(rand.next(), 0);
ignore Map.get(map, Nat32.compare, x);
let x = Option.get<Nat64>(rand.next(), 0);
ignore Map.get(map, Nat64.compare, x);
};
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
ignore Map.insert(map, Nat32.compare, k, debug_show k);
let k = Option.get<Nat64>(rand.next(), 0);
ignore Map.insert(map, Nat64.compare, k, k);
};
};
public func batch_remove(n : Nat) : async () {
let rand = Random.new(null, 1);
for (_ in Iter.range(1, n)) {
let x = Option.get<Nat32>(rand.next(), 0);
ignore Map.delete(map, Nat32.compare, x);
let x = Option.get<Nat64>(rand.next(), 0);
ignore Map.delete(map, Nat64.compare, x);
};
};
};
44 changes: 12 additions & 32 deletions collections/motoko/src/hashmap.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,59 +1,39 @@
import HashMap "mo:base/HashMap";
import Nat64 "mo:base/Nat64";
import Nat32 "mo:base/Nat32";
import { hashNat8 } "mo:base/Hash";
import Hash "mo:base/Hash";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";

actor {
func hash(x: Nat32) : Nat32 = hashNat8([x & (255 << 0),
x & (255 << 8),
x & (255 << 16),
x & (255 << 24)
]);
var map = HashMap.HashMap<Nat32, Text>(0, Nat32.equal, hash);
func hash(x: Nat64) : Nat32 = Hash.hash(Nat64.toNat x);
var map = HashMap.HashMap<Nat64, Nat64>(0, Nat64.equal, hash);
let rand = Random.new(null, 42);

stable var stable_map : [(Nat32, Text)] = [];

system func preupgrade() {
stable_map := Iter.toArray(map.entries());
};
system func postupgrade() {
map := HashMap.fromIter(stable_map.vals(), 50_000, Nat32.equal, hash);
};

public func generate(size: Nat) : async () {
public func generate(size: Nat32) : async () {
let rand = Random.new(?size, 1);
let iter = Iter.map<Nat32, (Nat32, Text)>(rand, func x = (x, debug_show x));
map := HashMap.fromIter(iter, size, Nat32.equal, hash);
};
public func get(x : Nat32) : async ?Text {
map.get(x)
};
public func put(k : Nat32, v : Text) : async () {
map.put(k, v);
};
public func remove(x : Nat32) : async ?Text {
map.remove(x)
let iter = Iter.map<Nat64, (Nat64, Nat64)>(rand, func x = (x, x));
map := HashMap.fromIter(iter, Nat32.toNat size, Nat64.equal, hash);
};
public query func get_mem() : async (Nat,Nat,Nat) {
Random.get_memory()
};
public func batch_get(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
ignore map.get(Option.get<Nat32>(rand.next(), 0));
ignore map.get(Option.get<Nat64>(rand.next(), 0));
}
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
map.put(k, debug_show k);
let k = Option.get<Nat64>(rand.next(), 0);
map.put(k, k);
}
};
public func batch_remove(n : Nat) : async () {
let rand = Random.new(null, 1);
for (_ in Iter.range(1, n)) {
ignore map.remove(Option.get<Nat32>(rand.next(), 0));
ignore map.remove(Option.get<Nat64>(rand.next(), 0));
}
};
}
19 changes: 5 additions & 14 deletions collections/motoko/src/heap.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,26 +1,17 @@
import Heap "mo:base/Heap";
import Nat32 "mo:base/Nat32";
import Nat64 "mo:base/Nat64";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";
import O "mo:base/Order";

actor {
var map = Heap.Heap<Nat32>(Nat32.compare);
var map = Heap.Heap<Nat64>(Nat64.compare);
let rand = Random.new(null, 42);

stable var stable_map : Heap.Tree<Nat32> = null;

system func preupgrade() {
stable_map := map.share();
};
system func postupgrade() {
map.unsafeUnshare(stable_map);
};

public func generate(size: Nat) : async () {
public func generate(size: Nat32) : async () {
let rand = Random.new(?size, 1);
map := Heap.fromIter(rand, Nat32.compare);
map := Heap.fromIter(rand, Nat64.compare);
};

public query func get_mem() : async (Nat,Nat,Nat) {
Expand All @@ -33,7 +24,7 @@ actor {
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
let k = Option.get<Nat64>(rand.next(), 0);
map.put(k);
}
};
Expand Down
12 changes: 6 additions & 6 deletions collections/motoko/src/random.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,12 +3,12 @@ import Nat32 = "mo:base/Nat32";
import Prim "mo:⛔";

module {
public class new(size: ?Nat, seed: Nat32) {
let modulus = 0x7fffffff;
var state : Nat32 = seed;
var ind = 0;
public class new(size: ?Nat32, seed: Nat64) {
let modulus : Nat64 = 0x7fffffff;
var state : Nat64 = seed;
var ind : Nat32 = 0;

public func next() : ?Nat32 {
public func next() : ?Nat64 {
switch size {
case null ();
case (?size) {
Expand All @@ -18,7 +18,7 @@ module {
};
};
};
state := Nat32.fromNat(Nat32.toNat(state) * 48271 % modulus);
state := state * 48271 % modulus;
?state;
};
};
Expand Down
35 changes: 9 additions & 26 deletions collections/motoko/src/rbtree.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,55 +1,38 @@
import RBTree "mo:base/RBTree";
import Nat32 "mo:base/Nat32";
import Nat64 "mo:base/Nat64";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";

actor {
var map = RBTree.RBTree<Nat32, Text>(Nat32.compare);
var map = RBTree.RBTree<Nat64, Nat64>(Nat64.compare);
let rand = Random.new(null, 42);

stable var stable_map : RBTree.Tree<Nat32, Text> = #leaf;

system func preupgrade() {
stable_map := map.share();
};
system func postupgrade() {
// unshare is missing, if it exists, it will be one assignment
};

public func generate(size: Nat) : async () {
public func generate(size: Nat32) : async () {
let rand = Random.new(?size, 1);
let iter = Iter.map<Nat32, (Nat32, Text)>(rand, func x = (x, debug_show x));
let iter = Iter.map<Nat64, (Nat64, Nat64)>(rand, func x = (x, x));
for ((k,v) in iter) {
map.put(k, v);
}
};
public func get(x : Nat32) : async ?Text {
map.get(x)
};
public func put(k : Nat32, v : Text) : async () {
map.put(k, v);
};
public func remove(x : Nat32) : async ?Text {
map.remove(x)
};
public query func get_mem() : async (Nat,Nat,Nat) {
Random.get_memory()
};
public func batch_get(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
ignore map.get(Option.get<Nat32>(rand.next(), 0));
ignore map.get(Option.get<Nat64>(rand.next(), 0));
}
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
map.put(k, debug_show k);
let k = Option.get<Nat64>(rand.next(), 0);
map.put(k, k);
}
};
public func batch_remove(n : Nat) : async () {
let rand = Random.new(null, 1);
for (_ in Iter.range(1, n)) {
ignore map.remove(Option.get<Nat32>(rand.next(), 0));
ignore map.remove(Option.get<Nat64>(rand.next(), 0));
}
};
}
37 changes: 10 additions & 27 deletions collections/motoko/src/splay.mo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,57 +1,40 @@
import Splay "mo:splay";
import Nat32 "mo:base/Nat32";
import Nat64 "mo:base/Nat64";
import Iter "mo:base/Iter";
import Option "mo:base/Option";
import Random "random";
import O "mo:base/Order";

actor {
func compare(x: (Nat32, Text), y: (Nat32, Text)) : O.Order = Nat32.compare(x.0, y.0);
var map = Splay.Splay<(Nat32, Text)>(compare);
func compare(x: (Nat64, Nat64), y: (Nat64, Nat64)) : O.Order = Nat64.compare(x.0, y.0);
var map = Splay.Splay<(Nat64, Nat64)>(compare);
let rand = Random.new(null, 42);

stable var stable_map : [(Nat32, Text)] = [];

system func preupgrade() {
stable_map := Iter.toArray(map.entries());
};
system func postupgrade() {
map.fromArray(stable_map);
};

public func generate(size: Nat) : async () {
public func generate(size: Nat32) : async () {
let rand = Random.new(?size, 1);
let iter = Iter.map<Nat32, (Nat32, Text)>(rand, func x = (x, debug_show x));
let iter = Iter.map<Nat64, (Nat64, Nat64)>(rand, func x = (x, x));
for ((k,v) in iter) {
map.insert((k, v));
}
};
public func get(x : Nat32) : async Bool {
map.find((x, ""))
};
public func put(k : Nat32, v : Text) : async () {
map.insert((k, v));
};
public func remove(x : Nat32) : async () {
map.remove((x, ""))
};
public query func get_mem() : async (Nat,Nat,Nat) {
Random.get_memory()
};
public func batch_get(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
ignore map.find((Option.get<Nat32>(rand.next(), 0), ""));
ignore map.find((Option.get<Nat64>(rand.next(), 0), 0));
}
};
public func batch_put(n : Nat) : async () {
for (_ in Iter.range(1, n)) {
let k = Option.get<Nat32>(rand.next(), 0);
map.insert((k, debug_show k));
let k = Option.get<Nat64>(rand.next(), 0);
map.insert((k, k));
}
};
public func batch_remove(n : Nat) : async () {
let rand = Random.new(null, 1);
for (_ in Iter.range(1, n)) {
map.remove((Option.get<Nat32>(rand.next(), 0), ""));
map.remove((Option.get<Nat64>(rand.next(), 0), 0));
}
};
}
Loading
Loading