impl-libc/impl-libc.c

   1 #include <errno.h>
   2 #include <math.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include <unistd.h>
   8
   9 /* Whether we're looking at 32-bit or 64-bit floats */
  10 typedef enum { P_SINGLE, P_DOUBLE } precision;
  11
  12 /* What type of arguments we expect, and what we'll give back. */
  13 typedef enum {
  14         /* */
  15         A_UNKNOWN,
  16         A__FLT__FLT,
  17         A__FLT_FLT_FLT__FLT,
  18 } argtype;
  19
  20 /* Types of functions we could call */
  21 typedef float (*f__f32__f32)(float);
  22 typedef float (*f__f32_f32_f32__f32)(float, float, float);
  23 typedef double (*f__f64__f64)(double);
  24 typedef double (*f__f64_f64_f64__f64)(double, double, double);
  25
  26 /* Wrapper around a function pointer */
  27 typedef struct {
  28         /* */
  29         precision p;
  30         argtype a;
  31
  32         union {
  33                 /* */
  34                 f__f32__f32 f32__f32;
  35                 f__f32_f32_f32__f32 f32_f32_f32__f32;
  36         } f32;
  37
  38         union {
  39                 /* */
  40                 f__f64__f64 f64__f64;
  41                 f__f64_f64_f64__f64 f64_f64_f64__f64;
  42         } f64;
  43
  44 } action;
  45
  46 void usage(void)
  47 {
  48         fprintf(stderr,
  49                 "usage: impl-libc [-s|-d] -f <function_name> -n <num_inputs>\n");
  50         _exit(1);
  51 }
  52
  53 float idf(float f)
  54 {
  55         return f;
  56 }
  57
  58 double idd(double d)
  59 {
  60         return d;
  61 }
  62
  63 void determine_function(const char *f, action *a)
  64 {
  65         if (!strcmp(f, "zzzzzz")) {
  66                 a->a = A_UNKNOWN;
  67         } else if (!strcmp(f, "id")) {
  68                 a->a = A__FLT__FLT;
  69                 a->f32.f32__f32 = idf;
  70                 a->f64.f64__f64 = idd;
  71         } else if (!strcmp(f, "ceil")) {
  72                 a->a = A__FLT__FLT;
  73                 a->f32.f32__f32 = ceilf;
  74                 a->f64.f64__f64 = ceil;
  75         } else if (!strcmp(f, "cos")) {
  76                 a->a = A__FLT__FLT;
  77                 a->f32.f32__f32 = cosf;
  78                 a->f64.f64__f64 = cos;
  79         } else if (!strcmp(f, "floor")) {
  80                 a->a = A__FLT__FLT;
  81                 a->f32.f32__f32 = floorf;
  82                 a->f64.f64__f64 = floor;
  83         } else if (!strcmp(f, "sin")) {
  84                 a->a = A__FLT__FLT;
  85                 a->f32.f32__f32 = sinf;
  86                 a->f64.f64__f64 = sin;
  87         } else if (!strcmp(f, "trunc")) {
  88                 a->a = A__FLT__FLT;
  89                 a->f32.f32__f32 = truncf;
  90                 a->f64.f64__f64 = trunc;
  91         } else if (!strcmp(f, "fma")) {
  92                 a->a = A__FLT_FLT_FLT__FLT;
  93                 a->f32.f32_f32_f32__f32 = fmaf;
  94                 a->f64.f64_f64_f64__f64 = fma;
  95         } else {
  96                 fprintf(stderr, "impl-libc: unknown function \"%s\"\n", f);
  97                 _exit(1);
  98         }
  99 }
 100
 101 void read_buf(char *b, ssize_t len)
 102 {
 103         ssize_t r;
 104         ssize_t total = 0;
 105
 106         while (total < len) {
 107                 r = read(0, (b + total), (len - total));
 108
 109                 if (!r) {
 110                         /* EOF */
 111                         _exit(0);
 112                 } else if (r == -1) {
 113                         perror("impl-libc: read");
 114                         _exit(1);
 115                 } else {
 116                         total += r;
 117                 }
 118         }
 119 }
 120
 121 void write_buf(const char *b, ssize_t len)
 122 {
 123         ssize_t r;
 124         ssize_t total = 0;
 125
 126         while (total < len) {
 127                 r = write(1, (b + total), (len - total));
 128
 129                 if (r == -1) {
 130                         perror("impl-libc: write");
 131                         _exit(1);
 132                 } else {
 133                         total += r;
 134                 }
 135         }
 136 }
 137
 138 size_t input_width(argtype a, precision p)
 139 {
 140         size_t w = (p == P_SINGLE) ? 4 : 8;
 141
 142         switch (a) {
 143         case A_UNKNOWN:
 144                 break;
 145         case A__FLT__FLT:
 146
 147                 return 1 * w;
 148         case A__FLT_FLT_FLT__FLT:
 149
 150                 return 3 * w;
 151         }
 152
 153         return (size_t) -1;
 154 }
 155
 156 size_t output_width(argtype a, precision p)
 157 {
 158         size_t w = (p == P_SINGLE) ? 4 : 8;
 159
 160         switch (a) {
 161         case A_UNKNOWN:
 162                 break;
 163         case A__FLT__FLT:
 164
 165                 return 1 * w;
 166         case A__FLT_FLT_FLT__FLT:
 167
 168                 return 1 * w;
 169         }
 170
 171         return (size_t) -1;
 172 }
 173
 174 void io_loop(action a, size_t n)
 175 {
 176         char *in_buf = 0;
 177         char *out_buf = 0;
 178         size_t in_sz = input_width(a.a, a.p);
 179         size_t out_sz = output_width(a.a, a.p);
 180
 181         if ((in_sz * n) / n != in_sz) {
 182                 fprintf(stderr, "impl-libc: input length overflow\n");
 183                 _exit(1);
 184         }
 185
 186         if ((out_sz * n) / n != out_sz) {
 187                 fprintf(stderr, "impl-libc: output length overflow\n");
 188                 _exit(1);
 189         }
 190
 191         if (!(in_buf = malloc(in_sz * n))) {
 192                 perror("impl-libc: malloc");
 193                 _exit(1);
 194         }
 195
 196         if (!(out_buf = malloc(out_sz * n))) {
 197                 perror("impl-libc: malloc");
 198                 _exit(1);
 199         }
 200
 201         while (1) {
 202                 read_buf(in_buf, in_sz * n);
 203
 204                 switch (a.a) {
 205                 case A_UNKNOWN:
 206                         fprintf(stderr, "impl-libc: impossible\n");
 207                         _exit(1);
 208                         break;
 209                 case A__FLT__FLT:
 210
 211                         switch (a.p) {
 212                         case P_SINGLE:
 213
 214                                 for (size_t j = 0; j < n; ++j) {
 215                                         float *x = (float *) (in_buf + (in_sz *
 216                                                                         j));
 217                                         float *y = (float *) (out_buf +
 218                                                               (out_sz * j));
 219
 220                                         *y = a.f32.f32__f32(*x);
 221                                 }
 222
 223                                 break;
 224                         case P_DOUBLE:
 225
 226                                 for (size_t j = 0; j < n; ++j) {
 227                                         double *x = (double *) (in_buf +
 228                                                                 (in_sz * j));
 229                                         double *y = (double *) (out_buf +
 230                                                                 (out_sz * j));
 231
 232                                         *y = a.f64.f64__f64(*x);
 233                                 }
 234
 235                                 break;
 236                         }
 237
 238                         break;
 239                 case A__FLT_FLT_FLT__FLT:
 240
 241                         switch (a.p) {
 242                         case P_SINGLE:
 243
 244                                 for (size_t j = 0; j < n; ++j) {
 245                                         float *x1 = (float *) (in_buf + (in_sz *
 246                                                                          j));
 247                                         float *x2 = (float *) (in_buf + (in_sz *
 248                                                                          j +
 249                                                                          4));
 250                                         float *x3 = (float *) (in_buf + (in_sz *
 251                                                                          j +
 252                                                                          8));
 253                                         float *y = (float *) (out_buf +
 254                                                               (out_sz * j));
 255
 256                                         *y = a.f32.f32_f32_f32__f32(*x1, *x2,
 257                                                                     *x3);
 258                                 }
 259
 260                                 break;
 261                         case P_DOUBLE:
 262
 263                                 for (size_t j = 0; j < n; ++j) {
 264                                         double *x1 = (double *) (in_buf +
 265                                                                  (in_sz * j));
 266                                         double *x2 = (double *) (in_buf +
 267                                                                  (in_sz * j) +
 268                                                                  8);
 269                                         double *x3 = (double *) (in_buf +
 270                                                                  (in_sz * j) +
 271                                                                  16);
 272                                         double *y = (double *) (out_buf +
 273                                                                 (out_sz * j));
 274
 275                                         *y = a.f64.f64_f64_f64__f64(*x1, *x2,
 276                                                                     *x3);
 277                                 }
 278
 279                                 break;
 280                         }
 281
 282                         break;
 283                 }
 284
 285                 write_buf(out_buf, out_sz * n);
 286         }
 287 }
 288
 289 int main(int argc, char **argv)
 290 {
 291         int c = 0;
 292         action a = { .p = P_SINGLE };
 293         long long n = 0;
 294
 295         while ((c = getopt(argc, argv, "sdf:n:")) != -1) {
 296                 switch (c) {
 297                 case 's':
 298                         a.p = P_SINGLE;
 299                         break;
 300                 case 'd':
 301                         a.p = P_DOUBLE;
 302                         break;
 303                 case 'f':
 304                         determine_function(optarg, &a);
 305                         break;
 306                 case 'n':
 307                         errno = 0;
 308                         n = strtoll(optarg, 0, 0);
 309
 310                         if (errno) {
 311                                 perror("impl-libc: unparsable");
 312
 313                                 return 1;
 314                         }
 315
 316                         break;
 317                 default:
 318                         usage();
 319                         break;
 320                 }
 321         }
 322
 323         if (a.a == A_UNKNOWN) {
 324                 usage();
 325         }
 326
 327         io_loop(a, n);
 328 }