nv-buf-storage 1.3.2

package/TEST/perf.js

@@ -0,0 +1,733 @@
+const x = require("../index");
+
+var buf = x();
+
+var ROUNDS = Number(process.argv[2] ?? 1000000)
+
+function now(){
+    return Date.now(); 
+}
+
+function print(name,start,end,rounds){
+    const ms = Number(end-start)
+    console.log(name)
+    console.log("  rounds :",rounds)
+    console.log("  total  :",ms,"ms")
+    console.log("  op/ms  :",rounds/ms)
+}
+
+
+// u8 write
+function perf_write_u8() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu8(i&255)
+    }
+    let t1 = now()
+    print("write u8",t0,t1,ROUNDS)
+}
+
+
+// u8 read
+function perf_read_u8(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wu8(i&255)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru8(rs[i])
+    }
+    let t1 = now()
+    print("read u8",t0,t1,ROUNDS)
+}
+
+// i8 write
+function perf_write_i8() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wi8(i&255)
+    }
+    let t1 = now()
+    print("write i8",t0,t1,ROUNDS)
+}
+
+
+// i8 read
+function perf_read_i8(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wi8(i&255)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ri8(rs[i])
+    }
+    let t1 = now()
+    print("read i8",t0,t1,ROUNDS)
+}
+
+// u16 write
+function perf_write_u16(){
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu16(i%65536);
+        //if(i%10000===0) {console.log(i);console.log(buf._fl.list_all_free_rngs())}
+    }
+    let t1 = now()
+    print("write u16",t0,t1,ROUNDS)
+}
+
+
+// u16 read
+function perf_read_u16(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wu16(i%65536)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru16(rs[i])
+    }
+    let t1 = now()
+    print("read u16",t0,t1,ROUNDS)
+}
+
+// i16 write
+function perf_write_i16() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wi16(i&255)
+    }
+    let t1 = now()
+    print("write i16",t0,t1,ROUNDS)
+}
+
+
+// i16 read
+function perf_read_i16(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wi16(i&255)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ri16(rs[i])
+    }
+    let t1 = now()
+    print("read i16",t0,t1,ROUNDS)
+}
+
+// u32 write
+function perf_write_u32(){
+
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu32(i);
+	//if(i%10000===0) {console.log(i);console.log(buf._fl.list_all_free_rngs())}
+    }
+
+    let t1 = now()
+
+    print("write u32",t0,t1,ROUNDS)
+}
+
+
+// u32 read
+function perf_read_u32(){
+
+
+    let rs = new Array(ROUNDS)
+
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wu32(i)
+    }
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru32(rs[i])
+    }
+
+    let t1 = now()
+
+    print("read u32",t0,t1,ROUNDS)
+}
+
+// i32 write
+function perf_write_i32() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wi32(i&255)
+    }
+    let t1 = now()
+    print("write i32",t0,t1,ROUNDS)
+}
+
+
+// i32 read
+function perf_read_i32(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wi32(i&255)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ri32(rs[i])
+    }
+    let t1 = now()
+    print("read i32",t0,t1,ROUNDS)
+}
+// u64 write
+function perf_write_u64() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu64(BigInt(i))
+    }
+    let t1 = now()
+    print("write u64",t0,t1,ROUNDS)
+}
+
+
+// u64 read
+function perf_read_u64(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wu64(BigInt(i))
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru64(rs[i])
+    }
+    let t1 = now()
+    print("read u64",t0,t1,ROUNDS)
+}
+
+// i64 write
+function perf_write_i64() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wi64(BigInt(i))
+    }
+    let t1 = now()
+    print("write i64",t0,t1,ROUNDS)
+}
+
+
+// i64 read
+function perf_read_i64(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wi64(BigInt(i))
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ri64(rs[i])
+    }
+    let t1 = now()
+    print("read i64",t0,t1,ROUNDS)
+}
+
+// f32 write
+function perf_write_f32() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wf32(Math.random())
+    }
+    let t1 = now()
+    print("write f32",t0,t1,ROUNDS)
+}
+
+
+// f32 read
+function perf_read_f32(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wf32(Math.random())
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.rf32(rs[i])
+    }
+    let t1 = now()
+    print("read f32",t0,t1,ROUNDS)
+}
+
+// f64 write
+function perf_write_f64() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wf64(Math.random())
+    }
+    let t1 = now()
+    print("write f64",t0,t1,ROUNDS)
+}
+
+
+// f64 read
+function perf_read_f64(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wf64(Math.random())
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.rf64(rs[i])
+    }
+    let t1 = now()
+    print("read f64",t0,t1,ROUNDS)
+}
+
+
+// string write
+function perf_write_str(){
+
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.wstr("abcd")
+    }
+
+    let t1 = now()
+
+    print("write str",t0,t1,ROUNDS)
+}
+
+
+// string read
+function perf_read_str(){
+
+
+    let rs = new Array(ROUNDS)
+
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] = buf.wstr("abcd")
+    }
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.rstr(rs[i])
+    }
+
+    let t1 = now()
+
+    print("read str",t0,t1,ROUNDS)
+}
+
+
+
+// circular object
+let circular = [];
+{
+    var st = new Set([])
+    for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]) {
+        st.add(e)
+    }
+    var mp = new Map()
+    let dict = {a:100,b:-0}
+    let ary  = [0,1,2,3]
+    for(let e of [[{},[]],[true,false],[dict,dict],[ary,ary]]) {
+        mp.set(e,e)
+    }
+    for(let e of [[]]) {
+        mp.set(e,e)
+    }
+    for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n]) {
+        mp.set(e,e)
+    }
+    circular[0]  = circular
+    circular[1]  = {pr:circular[0]}
+    circular[2]  = mp
+    st.add(mp)
+    mp.set("set",st);
+}
+
+
+// circular write
+function perf_write_circular(){
+
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.debug_write(circular)
+    }
+
+    let t1 = now()
+
+    print("write circular",t0,t1,ROUNDS)
+}
+
+
+// circular read
+function perf_read_circular(){
+
+
+    let r = buf.debug_write(circular)
+
+    let t0 = now()
+
+    for(let i=0;i<ROUNDS;i++){
+        buf.debug_read(...r)
+    }
+
+    let t1 = now()
+
+    print("read circular",t0,t1,ROUNDS)
+}
+
+
+
+perf_write_u8()
+perf_read_u8()
+console.log(buf._fl.list_all_free_rngs())
+console.log(buf.wu32(250))
+console.log(buf._fl.list_all_free_rngs())
+
+perf_write_i8();
+perf_read_i8();
+
+perf_write_u16();
+perf_read_u16();
+perf_write_u32();
+perf_read_u32();
+perf_write_i32();
+perf_read_i32();
+
+perf_write_u64();
+perf_read_u64();
+perf_write_i64();
+perf_read_i64();
+
+perf_write_f32();
+perf_read_f32();
+perf_write_f64();
+perf_read_f64();
+
+perf_write_str();
+perf_read_str();
+
+const U8A  = new Uint8Array(10);            crypto.getRandomValues(U8A);
+const U8CA= new Uint8ClampedArray(10);      crypto.getRandomValues(U8CA);
+const I8A  = new Int8Array(10);            crypto.getRandomValues(I8A);
+
+const U16A  = new Uint16Array(10);            crypto.getRandomValues(new Uint8Array(U16A.buffer));
+const I16A  = new Int16Array(10);            crypto.getRandomValues(new Uint8Array(I16A.buffer));
+
+const U32A = new Uint32Array(10);              // 32-bit unsigned integers
+crypto.getRandomValues(U32A);
+
+const I32A = new Int32Array(10);               // 32-bit signed integers
+crypto.getRandomValues(I32A);
+
+const F32A = new Float32Array(10);             // 32-bit floating-point numbers
+crypto.getRandomValues(new Uint8Array(F32A.buffer));
+
+const F64A = new Float64Array(10);             // 64-bit floating-point numbers
+crypto.getRandomValues(new Uint8Array(F64A.buffer));
+
+const BigUint64A = new BigUint64Array(10);     // 64-bit unsigned big integers (requires BigInt)
+crypto.getRandomValues(BigUint64A);
+
+const BigInt64A = new BigInt64Array(10);       // 64-bit signed big integers (requires BigInt)
+crypto.getRandomValues(BigInt64A);
+
+// u8a write
+function perf_write_u8a() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu8a(U8A)
+    }
+    let t1 = now()
+    print("write u8a",t0,t1,ROUNDS)
+}
+
+
+// u8a read
+function perf_read_u8a(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] =  buf.wu8a(U8A)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru8a(rs[i])
+    }
+    let t1 = now()
+    print("read u8a",t0,t1,ROUNDS)
+}
+
+function perf_write_u8ca() {
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.wu8ca(U8CA)
+    }
+    let t1 = now()
+    print("write u8ca",t0,t1,ROUNDS)
+}
+
+
+// u8a read
+function perf_read_u8ca(){
+    let rs = new Array(ROUNDS)
+    for(let i=0;i<ROUNDS;i++){
+        rs[i] =  buf.wu8ca(U8CA)
+    }
+    let t0 = now()
+    for(let i=0;i<ROUNDS;i++){
+        buf.ru8ca(rs[i])
+    }
+    let t1 = now()
+    print("read u8ca",t0,t1,ROUNDS)
+}
+
+// Write Performance for Uint16Array
+function perf_write_u16a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wu16a(U16A);
+    }
+    let t1 = now();
+    print("write u16a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Uint16Array
+function perf_read_u16a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wu16a(U16A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ru16a(rs[i]);
+    }
+    let t1 = now();
+    print("read u16a", t0, t1, ROUNDS);
+}
+
+// Write Performance for Int8Array
+function perf_write_i8a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wi8a(I8A);
+    }
+    let t1 = now();
+    print("write i8a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Int8Array
+function perf_read_i8a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wi8a(I8A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ri8a(rs[i]);
+    }
+    let t1 = now();
+    print("read i8a", t0, t1, ROUNDS);
+}
+
+// Write Performance for Int16Array
+function perf_write_i16a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wi16a(I16A);
+    }
+    let t1 = now();
+    print("write i16a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Int16Array
+function perf_read_i16a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wi16a(I16A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ri16a(rs[i]);
+    }
+    let t1 = now();
+    print("read i16a", t0, t1, ROUNDS);
+}
+
+// Write Performance for Int32Array
+function perf_write_i32a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wi32a(I32A);
+    }
+    let t1 = now();
+    print("write i32a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Int32Array
+function perf_read_i32a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wi32a(I32A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ri32a(rs[i]);
+    }
+    let t1 = now();
+    print("read i32a", t0, t1, ROUNDS);
+}
+
+// Write Performance for Int32Array
+function perf_write_u32a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wu32a(I32A);
+    }
+    let t1 = now();
+    print("write u32a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Int32Array
+function perf_read_u32a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wu32a(I32A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ru32a(rs[i]);
+    }
+    let t1 = now();
+    print("read u32a", t0, t1, ROUNDS);
+}
+
+
+// Write Performance for Float32Array
+function perf_write_f32a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wf32a(F32A);
+    }
+    let t1 = now();
+    print("write f32a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Float32Array
+function perf_read_f32a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wf32a(F32A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.rf32a(rs[i]);
+    }
+    let t1 = now();
+    print("read f32a", t0, t1, ROUNDS);
+}
+
+// Write Performance for Float64Array
+function perf_write_f64a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wf64a(F64A);
+    }
+    let t1 = now();
+    print("write f64a", t0, t1, ROUNDS);
+}
+
+// Read Performance for Float64Array
+function perf_read_f64a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wf64a(F64A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.rf64a(rs[i]);
+    }
+    let t1 = now();
+    print("read f64a", t0, t1, ROUNDS);
+}
+
+// Write Performance for BigInt64Array
+function perf_write_i64a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wi64a(BigInt64A);
+    }
+    let t1 = now();
+    print("write i64a", t0, t1, ROUNDS);
+}
+
+// Read Performance for BigInt64Array
+function perf_read_i64a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wi64a(BigInt64A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ri64a(rs[i]);
+    }
+    let t1 = now();
+    print("read i64a", t0, t1, ROUNDS);
+}
+
+// Write Performance for BigUint64Array
+function perf_write_u64a() {
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.wu64a(BigUint64A);
+    }
+    let t1 = now();
+    print("write u64a", t0, t1, ROUNDS);
+}
+
+// Read Performance for BigUint64Array
+function perf_read_u64a() {
+    let rs = new Array(ROUNDS);
+    for (let i = 0; i < ROUNDS; i++) {
+        rs[i] = buf.wu64a(BigUint64A);
+    }
+    let t0 = now();
+    for (let i = 0; i < ROUNDS; i++) {
+        buf.ru64a(rs[i]);
+    }
+    let t1 = now();
+    print("read u64a", t0, t1, ROUNDS);
+}
+perf_write_u8a();
+perf_read_u8a();
+perf_write_u8ca();
+perf_read_u8ca();
+perf_write_i8a();
+perf_read_i8a();
+perf_write_u16a();
+perf_read_u16a();
+perf_write_i16a();
+perf_read_i16a();
+
+perf_write_u32a();
+perf_read_u32a();
+perf_write_i32a();
+perf_read_i32a();
+
+perf_write_u64a();
+perf_read_u64a();
+perf_write_i64a();
+perf_read_i64a();
+
+perf_write_f32a();
+perf_read_f32a();
+perf_write_f64a();
+perf_read_f64a();
+
+perf_write_circular()
+perf_read_circular()
+
+

package/TEST/tst.sh

@@ -0,0 +1,9 @@
+node check.js
+node check-date.js
+node check-rgx.js
+node check-ta.js
+node check-json.js
+node check-dump-load.js
+
+
+