| 1 |
// Start of values.js |
| 2 |
var futharkPrimtypes = |
| 3 |
new Set([ |
| 4 |
'i8', |
| 5 |
'i16', |
| 6 |
'i32', |
| 7 |
'i64', |
| 8 |
'u8', |
| 9 |
'u16', |
| 10 |
'u32', |
| 11 |
'u64', |
| 12 |
'f16', |
| 13 |
'f32', |
| 14 |
'f64', |
| 15 |
'bool']); |
| 16 |
|
| 17 |
|
| 18 |
var typToType = { ' i8' : Int8Array , |
| 19 |
' i16' : Int16Array , |
| 20 |
' i32' : Int32Array , |
| 21 |
' i64' : BigInt64Array , |
| 22 |
' u8' : Uint8Array , |
| 23 |
' u16' : Uint16Array , |
| 24 |
' u32' : Uint32Array , |
| 25 |
' u64' : BigUint64Array , |
| 26 |
' f16' : Uint16Array , |
| 27 |
' f32' : Float32Array , |
| 28 |
' f64' : Float64Array , |
| 29 |
'bool' : Uint8Array |
| 30 |
}; |
| 31 |
|
| 32 |
function binToStringArray(buff, array) { |
| 33 |
for (var i = 0; i < array.length; i++) { |
| 34 |
array[i] = buff[i]; |
| 35 |
} |
| 36 |
} |
| 37 |
|
| 38 |
function fileToBuff(fname) { |
| 39 |
var readline = require('readline'); |
| 40 |
var fs = require('fs'); |
| 41 |
var buff = fs.readFileSync(fname); |
| 42 |
return buff; |
| 43 |
} |
| 44 |
|
| 45 |
var typToSize = { |
| 46 |
"bool" : 1, |
| 47 |
" u8" : 1, |
| 48 |
" i8" : 1, |
| 49 |
" u16" : 2, |
| 50 |
" i16" : 2, |
| 51 |
" u32" : 4, |
| 52 |
" i32" : 4, |
| 53 |
" f16" : 2, |
| 54 |
" f32" : 4, |
| 55 |
" u64" : 8, |
| 56 |
" i64" : 8, |
| 57 |
" f64" : 8, |
| 58 |
} |
| 59 |
|
| 60 |
function toU8(ta) { |
| 61 |
return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength); |
| 62 |
} |
| 63 |
|
| 64 |
function construct_binary_value(v, typ) { |
| 65 |
var dims; |
| 66 |
var payload_bytes; |
| 67 |
var filler; |
| 68 |
if (v instanceof FutharkOpaque) { |
| 69 |
throw "Opaques are not supported"; |
| 70 |
} else if (v instanceof FutharkArray) { |
| 71 |
var t = v.futharkType(); |
| 72 |
var ftype = " ".slice(t.length) + t; |
| 73 |
var shape = v.shape(); |
| 74 |
var ta = v.toTypedArray(shape); |
| 75 |
var da = new BigInt64Array(shape); |
| 76 |
dims = shape.length; |
| 77 |
payload_bytes = da.byteLength + ta.byteLength; |
| 78 |
filler = (bytes) => { |
| 79 |
bytes.set(toU8(da), 7); |
| 80 |
bytes.set(toU8(ta), 7 + da.byteLength); |
| 81 |
} |
| 82 |
} else { |
| 83 |
var ftype = " ".slice(typ.length) + typ; |
| 84 |
dims = 0; |
| 85 |
payload_bytes = typToSize[ftype]; |
| 86 |
filler = (bytes) => { |
| 87 |
var scalar = new (typToType[ftype])([v]); |
| 88 |
bytes.set(toU8(scalar), 7); |
| 89 |
} |
| 90 |
} |
| 91 |
var total_bytes = 7 + payload_bytes; |
| 92 |
var bytes = new Uint8Array(total_bytes); |
| 93 |
bytes[0] = Buffer.from('b').readUInt8(); |
| 94 |
bytes[1] = 2; |
| 95 |
bytes[2] = dims; |
| 96 |
for (var i = 0; i < 4; i++) { |
| 97 |
bytes[3+i] = ftype.charCodeAt(i); |
| 98 |
} |
| 99 |
filler(bytes); |
| 100 |
return Buffer.from(bytes); |
| 101 |
} |
| 102 |
|
| 103 |
class Reader { |
| 104 |
constructor(f) { |
| 105 |
this.f = f; |
| 106 |
this.buff = fileToBuff(f); |
| 107 |
} |
| 108 |
|
| 109 |
read_bin_array(num_dim, typ) { |
| 110 |
var u8_array = new Uint8Array(num_dim * 8); |
| 111 |
binToStringArray(this.buff.slice(0, num_dim * 8), u8_array); |
| 112 |
var shape = new BigInt64Array(u8_array.buffer); |
| 113 |
var length = shape[0]; |
| 114 |
for (var i = 1; i < shape.length; i++) { |
| 115 |
length = length * shape[i]; |
| 116 |
} |
| 117 |
length = Number(length); |
| 118 |
var dbytes = typToSize[typ]; |
| 119 |
var u8_data = new Uint8Array(length * dbytes); |
| 120 |
binToStringArray(this.buff.slice(num_dim * 8, num_dim * 8 + dbytes * length), u8_data); |
| 121 |
var data = new (typToType[typ])(u8_data.buffer); |
| 122 |
var tmp_buff = this.buff.slice(num_dim * 8, num_dim * 8 + dbytes * length); |
| 123 |
this.buff = this.buff.slice(num_dim * 8 + dbytes * length); |
| 124 |
return [shape, data]; |
| 125 |
} |
| 126 |
|
| 127 |
read_bin_scalar(typ) { |
| 128 |
var size = typToSize[typ]; |
| 129 |
var u8_array = new Uint8Array(size); |
| 130 |
binToStringArray(this.buff, u8_array); |
| 131 |
var array = new (typToType[typ])(u8_array.buffer); |
| 132 |
this.buff = this.buff.slice(u8_array.length); // Update buff to be unread part of the string |
| 133 |
return array[0]; |
| 134 |
} |
| 135 |
|
| 136 |
skip_spaces() { |
| 137 |
while (this.buff.length > 0 && this.buff.slice(0, 1).toString().trim() == "") { |
| 138 |
this.buff = this.buff.slice(1); |
| 139 |
} |
| 140 |
} |
| 141 |
|
| 142 |
read_binary(typename, dim) { |
| 143 |
// Skip leading white space |
| 144 |
while (this.buff.slice(0, 1).toString().trim() == "") { |
| 145 |
this.buff = this.buff.slice(1); |
| 146 |
} |
| 147 |
if (this.buff[0] != 'b'.charCodeAt(0)) { |
| 148 |
throw "Not in binary format" |
| 149 |
} |
| 150 |
var version = this.buff[1]; |
| 151 |
if (version != 2) { |
| 152 |
throw "Not version 2"; |
| 153 |
} |
| 154 |
var num_dim = this.buff[2]; |
| 155 |
var typ = this.buff.slice(3, 7); |
| 156 |
this.buff = this.buff.slice(7); |
| 157 |
var exp_typ = "[]".repeat(dim) + typename; |
| 158 |
var given_typ = "[]".repeat(num_dim) + typ.toString().trim(); |
| 159 |
console.log(exp_typ); |
| 160 |
console.log(given_typ); |
| 161 |
if (exp_typ !== given_typ) { |
| 162 |
throw ("Expected type : " + exp_typ + ", Actual type : " + given_typ); |
| 163 |
} |
| 164 |
if (num_dim === 0) { |
| 165 |
return this.read_bin_scalar(typ); |
| 166 |
} else { |
| 167 |
return this.read_bin_array(num_dim, typ); |
| 168 |
} |
| 169 |
} |
| 170 |
|
| 171 |
get_buff() { |
| 172 |
return this.buff; |
| 173 |
} |
| 174 |
} |
| 175 |
|
| 176 |
// Function is redudant but is helpful for keeping consistent with python implementation |
| 177 |
function skip_spaces(reader) { |
| 178 |
reader.skip_spaces(); |
| 179 |
} |
| 180 |
|
| 181 |
function read_value(typename, reader) { |
| 182 |
var typ = typename; |
| 183 |
var dim = 0; |
| 184 |
while (typ.slice(0, 2) === "[]") { |
| 185 |
dim = dim + 1; |
| 186 |
typ = typ.slice(2); |
| 187 |
} |
| 188 |
if (!futharkPrimtypes.has(typ)) { |
| 189 |
throw ("Unkown type: " + typ); |
| 190 |
} |
| 191 |
|
| 192 |
var val = reader.read_binary(typ, dim); |
| 193 |
return val; |
| 194 |
} |
| 195 |
|
| 196 |
// End of values.js |