impl-myrddin/impl-myrddin.myr

   1 use std
   2
   3 use math
   4
   5 type Fn_flt__flt = struct
   6         f32 : (f : flt32 -> flt32)
   7         f64 : (f : flt64 -> flt64)
   8 ;;
   9
  10 type Fn_flt_flt_flt__flt = struct
  11         f32 : (f1 : flt32, f2 : flt32, f3 : flt32 -> flt32)
  12         f64 : (f1 : flt64, f2 : flt64, f3 : flt64 -> flt64)
  13 ;;
  14
  15 type fn_desc = struct
  16         name : byte[:]
  17         f : union
  18                 `Flt__flt Fn_flt__flt
  19                 `Flt_flt_flt__flt Fn_flt_flt_flt__flt
  20         ;;
  21 ;;
  22
  23 type flt_prec = union
  24         `Single
  25         `Double
  26 ;;
  27
  28 var available_fns : fn_desc[:] = [][:]
  29
  30 generic id : (a : @a -> @a) = {x; -> x}
  31
  32 const main = {args : byte[:][:]
  33         available_fns = [
  34                 [.name = "id",    .f = `Flt__flt         [ .f32 = id,         .f64 = id]],
  35                 [.name = "trunc", .f = `Flt__flt         [ .f32 = math.trunc, .f64 = math.trunc]],
  36                 [.name = "floor", .f = `Flt__flt         [ .f32 = math.floor, .f64 = math.floor]],
  37                 [.name = "ceil",  .f = `Flt__flt         [ .f32 = math.ceil,  .f64 = math.ceil]],
  38                 [.name = "fma",   .f = `Flt_flt_flt__flt [ .f32 = math.fma,   .f64 = math.fma]],
  39                 [.name = "sqrt",  .f = `Flt__flt [ .f32 = math.sqrt,  .f64 = math.sqrt]],
  40         ][:]
  41
  42         var p : flt_prec = `Single
  43         var f : fn_desc = available_fns[0]
  44         var n : std.size = 0
  45
  46         (p, f, n) = read_args(args)
  47
  48         io_loop(p, f, n)
  49 }
  50
  51 const read_args = {args : byte[:][:]
  52         var p : flt_prec = `Single
  53         var n : std.size = 0
  54         var fname : byte[:] = ""
  55         var fn : fn_desc = available_fns[0]
  56         var cmd = std.optparse(args, &[
  57                 .argdesc = "",
  58                 .opts = [
  59                         [.opt = 's', .desc = "use single precision (default)"],
  60                         [.opt = 'd', .desc = "use double precision"],
  61                         [.opt = 'n', .arg = "N", .desc = "read/write ‘N’ entries at a time"],
  62                         [.opt = 'f', .arg = "func", .desc = "use function ‘f’"],
  63                 ][:]
  64         ])
  65
  66         for opt : cmd.opts
  67                 match opt
  68                 | ('s', _): p = `Single
  69                 | ('d', _): p = `Double
  70                 | ('n', ns):
  71                         match std.intparse(ns)
  72                         | `std.Some np: n = np
  73                         | `std.None:
  74                                 std.put("impl-myrddin: unparsable number “{}”\n", ns)
  75                                 std.exit(1)
  76                         ;;
  77                 | ('f', fs): fname = fs
  78                 | _ : std.die("impl-myrddin: impossible\n")
  79                 ;;
  80         ;;
  81
  82         var good_fn : bool = false
  83         for f : available_fns
  84                 if std.eq(f.name, fname)
  85                         fn = f
  86                         good_fn = true
  87                         break
  88                 ;;
  89         ;;
  90
  91         if !good_fn
  92                 std.put("impl-myrddin: unknown function “{}”\n", fname)
  93                 std.exit(1)
  94         ;;
  95
  96         if n <= 0
  97                 std.put("impl-myrddin: positive number of entries required\n")
  98                 std.exit(1)
  99         ;;
 100
 101         -> (p, fn, n)
 102 }
 103
 104
 105 const io_loop = {p : flt_prec, fn : fn_desc, n : std.size
 106         var input_sz : std.size = 0
 107         var output_sz : std.size = 0
 108         var in_buf : byte[:] = [][:]
 109         var out_buf : byte[:] = [][:]
 110         var w = prec_width(p)
 111
 112         (input_sz, output_sz) = io_widths(p, fn)
 113
 114         if (((input_sz * n) / input_sz) != n) || (((output_sz * n) / output_sz) != n)
 115                 std.put("impl-myrddin: overflow in i/o buffer size\n")
 116                 std.exit(1)
 117         ;;
 118
 119         in_buf = std.slalloc(input_sz * n)
 120         out_buf = std.slalloc(output_sz * n)
 121
 122         while true
 123                 match std.readall(0, in_buf)
 124                 | `std.Ok _:
 125                 | `std.Err e:
 126                         std.put("impl-myrddin: std.readall(): {}\n", e)
 127                         std.exit(1)
 128                 ;;
 129
 130                 match (p, fn.f)
 131                 | (`Single, `Flt__flt f):
 132                         for var j = 0; j < n; ++j
 133                                 var ib : byte[:] = in_buf[j * w:(j + 1) * w]
 134                                 var ob : byte[:] = out_buf[j * w:(j + 1) * w]
 135                                 var x : flt32 = std.flt32frombits(std.getle32(ib))
 136                                 std.putle32(ob, std.flt32bits(f.f32(x)))
 137                         ;;
 138                 | (`Double, `Flt__flt f):
 139                         for var j = 0; j < n; ++j
 140                                 var ib : byte[:] = in_buf[j * w:(j + 1) * w]
 141                                 var ob : byte[:] = out_buf[j * w:(j + 1) * w]
 142                                 var x : flt64 = std.flt64frombits(std.getle64(ib))
 143                                 std.putle64(ob, std.flt64bits(f.f64(x)))
 144                         ;;
 145                 | (`Single, `Flt_flt_flt__flt f):
 146                         for var j = 0; j < n; ++j
 147                                 var ib : byte[:] = in_buf[j * 3 * w:(j + 1) * 3 * w]
 148                                 var ob : byte[:] = out_buf[j * w:(j + 1) * w]
 149                                 var x1 : flt32 = std.flt32frombits(std.getle32(ib[0: 4]))
 150                                 var x2 : flt32 = std.flt32frombits(std.getle32(ib[4: 8]))
 151                                 var x3 : flt32 = std.flt32frombits(std.getle32(ib[8:12]))
 152                                 std.putle32(ob, std.flt32bits(f.f32(x1, x2, x3)))
 153                         ;;
 154                 | (`Double, `Flt_flt_flt__flt f):
 155                         for var j = 0; j < n; ++j
 156                                 var ib : byte[:] = in_buf[j * 3 * w:(j + 1) * 3 * w]
 157                                 var ob : byte[:] = out_buf[j * w:(j + 1) * w]
 158                                 var x1 : flt64 = std.flt64frombits(std.getle64(ib[ 0: 8]))
 159                                 var x2 : flt64 = std.flt64frombits(std.getle64(ib[ 8:16]))
 160                                 var x3 : flt64 = std.flt64frombits(std.getle64(ib[16:24]))
 161                                 std.putle64(ob, std.flt64bits(f.f64(x1, x2, x3)))
 162                         ;;
 163                 ;;
 164
 165                 match std.writeall(1, out_buf)
 166                 | (_, `std.None):
 167                 | (_, `std.Some e):
 168                         std.put("impl-myrddin: std.writeall(): {}\n", e)
 169                         std.exit(1)
 170                 ;;
 171         ;;
 172 }
 173
 174 const prec_width = {p : flt_prec
 175         match p
 176         | `Single: -> 4
 177         | `Double: -> 8
 178         ;;
 179 }
 180
 181 const io_widths = {p : flt_prec, fn : fn_desc
 182         var w : std.size = prec_width(p)
 183
 184         match fn.f
 185         | `Flt__flt _ : -> (w, w)
 186         | `Flt_flt_flt__flt _ : -> (3*w, w)
 187         ;;
 188 }