src/benchs/gen.nit

   1 #!/usr/bin/env nit
   2
   3 # Microbenchmak generation for multiple language
   4 # Just a quick an dirty Nit script file :)
   5
   6 class Klass
   7         var id: Int
   8         var supers = new Array[Klass]
   9         var all_supers = new HashSet[Klass]
  10         redef fun to_s
  11         do
  12                 return "C{id}"
  13         end
  14 end
  15
  16
  17 class Generator
  18         var classes = new Array[Klass]
  19
  20         var width = 5
  21         var height = 5
  22         var superprobs: Array[Int] = [40, 20, 5]
  23
  24         fun genhier
  25         do
  26                 var i = 0
  27                 for w in [0..width[ do
  28                         var s: nullable Klass = null
  29                         for h in [0..height[ do
  30                                 i += 1
  31                                 var c = new Klass(i)
  32
  33                                 classes.add(c)
  34                                 c.all_supers.add(c)
  35                                 if s != null then
  36                                         c.supers.add(s)
  37                                         c.all_supers.add_all(s.all_supers)
  38                                 end
  39                                 s = c
  40                         end
  41                 end
  42
  43                 for j in [0..listlen[ do
  44                         var c = classes[classes.length - 1 - (j % classes.length)]
  45                         list.unshift(c)
  46                         unlist.push(c)
  47                 end
  48         end
  49
  50         # List of instantited class in the order to read
  51         var list = new List[Klass]
  52
  53         # List of instantited class in the order to push
  54         var unlist = new List[Klass]
  55
  56         var arraylen = 2000
  57         var loops = 10000
  58
  59         var listlen = 50
  60
  61         var file: nullable OFStream = null
  62         fun write(str: String)
  63         do
  64                 file.write(str)
  65                 file.write("\n")
  66         end
  67
  68         fun writenit(name: String)
  69         do
  70                 file = new OFStream.open("{name}.nit")
  71                 write "class Root\n\tfun id: Int do return 0\nend"
  72                 for c in classes do
  73                         write "class {c}"
  74                         if c.supers.is_empty then
  75                                 write "\tsuper Root"
  76                         else for s in c.supers do
  77                                 write "\tsuper {s}"
  78                         end
  79                         write "\tredef fun id do return {c.id}"
  80                         write "end"
  81                 end
  82                 write "class L[E]\n\tsuper Root\n\tvar item:E \n\tvar next: nullable L[E]\ninit(item:E,next: nullable L[E])do\n\tself.item = item\n\tself.next=next\nend\nend"
  83
  84                 write "fun fill: nullable L[Root]\ndo"
  85                 write "\tvar head: nullable L[Root] = null"
  86                 write "\tvar l: L[Root]"
  87                 for c in classes do
  88                         write "\tvar l{c} = new L[{c}](new {c}, null)"
  89                         write "\thead = new L[Root](l{c}, head)"
  90                 end
  91                 write "\thead = null"
  92                 write "for x in [0..{arraylen}[ do"
  93                 for i in [0..listlen[ do
  94                         var c = unlist[i]
  95                         write "\tvar l{i} = new L[{c}](new {c}, null)"
  96                         write "\thead = new L[Root](l{i}, head)"
  97                 end
  98                 write "end"
  99                 write "return head"
 100                 write "end"
 101
 102                 write "fun run(head1: nullable L[Root], head2: nullable L[Root]): Int\ndo"
 103                 write "\tvar cpt = 0"
 104                 write "\tvar y = {loops/list.length}"
 105                 write "\twhile y > 0 do"
 106                 write "\tvar n1 = head1"
 107                 write "\tvar n2 = head2"
 108                 write "\twhile not n1 is null do"
 109                 for i in [0..listlen[ do
 110                         var c = list[i]
 111                         write "\t\tvar l{i} = n1.item"
 112                         write "\t\tvar lc{i} = l{i}.as(L[{c}])"
 113                         write "\t\tvar c{i} = lc{i}.item"
 114                         write "\t\tn1 = n1.next"
 115                         if count then
 116                                 write "\t\tif c{i}.id == {c.id} then cpt += 1"
 117                         end
 118                         write "\t\tvar l2_{i} = n2.item"
 119                         write "\t\tvar lc2_{i} = l2_{i}.as(L[{c}])"
 120                         write "\t\tlc2_{i}.item = c{i}"
 121                         write "\t\tn2 = n2.next"
 122                 end
 123                 write "\tend"
 124                 write "y -= 1"
 125                 write "end"
 126                 write "return cpt"
 127                 write "end"
 128
 129                 write "var head = fill"
 130                 write "var loops = 25"
 131                 write "if not args.is_empty then loops = args.first.to_i "
 132                 write "for x in [0..loops[ do"
 133                 write "\tvar cpt = run(head, head)"
 134                 write "\tprint \"\{x\}:\tcpt:\{cpt\}\""
 135                 write "end"
 136                 file.close
 137         end
 138
 139         fun writejava(name: String, interfaces: Bool)
 140         do
 141                 var cl = ""
 142                 if interfaces then cl = "X"
 143                 file = new OFStream.open("{name}.java")
 144                 write "class {name} \{"
 145                 if interfaces then
 146                         write "static interface Root\n\t\{ int id(); \}"
 147                 else
 148                         write "static class Root\n\t\{ int id() \{ return 0;\} \}"
 149                 end
 150                 for c in classes do
 151                         if interfaces then
 152                                 write "static interface {c} "
 153                         else
 154                                 write "static class {c} "
 155                         end
 156                         if c.supers.is_empty then
 157                                 write "\textends Root"
 158                         else for s in [c.supers.first] do
 159                                 write "\textends {s}"
 160                         end
 161                         if interfaces then
 162                                 write "\{\}"
 163                                 write "static class X{c} implements {c}"
 164                         end
 165                         write "\{"
 166                         write "\tpublic int id() \{ return {c.id}; \}"
 167                         write "\}"
 168                 end
 169                 write "static class L<E>"
 170                 if interfaces then
 171                         write "implements Root \{"
 172                 else
 173                         write "extends Root \{"
 174                 end
 175                 write "\tE _item; E item() \{ return _item; \} void set_item(E i) \{ _item = i; \}"
 176                 write "\tL<E> _next; L<E> next() \{ return _next; \} void set_next(L<E> n) \{ _next = n; \}"
 177                 write "\tL(E i, L<E> n) \{ set_item(i); set_next(n); \}"
 178                 write "\tpublic int id() \{ return -1; \}"
 179                 write "\}"
 180
 181                 write "static L<Root> fill() \{"
 182                 write "\tL<Root> head = null;"
 183                 for c in classes do
 184                         write "\tL<{c}> l{c} = new L<{c}>(new {cl}{c}(), null);"
 185                         write "\thead = new L<Root>(l{c}, head);"
 186                 end
 187                 write "\thead = null;"
 188                 write "for (int x=0; x<{arraylen}; x++) \{"
 189                 for i in [0..listlen[ do
 190                         var c = unlist[i]
 191                         write "\tL<{c}> l{i} = new L<{c}>(new {cl}{c}(), null);"
 192                         write "\thead = new L<Root>(l{i}, head);"
 193                 end
 194                 write "\}"
 195                 write "return head;"
 196                 write "\}"
 197
 198                 write "static int run(L<Root> head1, L<Root> head2) \{"
 199                 write "\tint cpt = 0;"
 200                 write "\tint y = {loops/list.length};"
 201                 write "\twhile (y > 0) \{;"
 202                 write "\tL<Root> n1 = head1;"
 203                 write "\tL<Root> n2 = head2;"
 204                 write "\twhile (n1 != null) \{"
 205                 for i in [0..listlen[ do
 206                         var c = list[i]
 207                         write "\t\tRoot l{i} = n1.item();"
 208                         write "\t\tL<{c}> lc{i} = (L<{c}>)l{i};"
 209                         write "\t\t{c} c{i} = lc{i}.item();"
 210                         write "\t\tn1 = n1.next();"
 211                         if count then
 212                                 write "\t\tif (c{i}.id() == {c.id}) cpt += 1;"
 213                         end
 214                         write "\t\tRoot l2_{i} = n2.item();"
 215                         write "\t\tL<{c}> lc2_{i} = (L<{c}>)l2_{i};"
 216                         write "\t\tlc2_{i}.set_item(c{i});"
 217                         write "\t\tn2 = n2.next();"
 218                 end
 219                 write "\t\}"
 220                 write "y -= 1;"
 221                 write "\}"
 222                 write "return cpt;"
 223                 write "\}"
 224
 225                 write "static public void main(String args[]) \{"
 226                 write "L<Root> head = fill();"
 227                 write "int loops = 25;"
 228                 write "if (args.length > 0) loops = Integer.parseInt(args[0]);"
 229                 write "for (int x=0; x<loops; x++) \{"
 230                 write "\tint cpt = run(head, head);"
 231                 write "\tSystem.out.println(\"\" + x + \":\\t\" + cpt);"
 232                 write "\}"
 233                 write "\}"
 234                 write "\}"
 235                 file.close
 236         end
 237
 238         fun writecpp(name: String)
 239         do
 240                 file = new OFStream.open("{name}.cpp")
 241                 write "#include <iostream>"
 242                 write "#include <stdlib.h>"
 243                 write "class Root\n\t\{ public: virtual int id() \{ return 0;\} \};"
 244                 for c in classes do
 245                         write "class {c} "
 246                         if c.supers.is_empty then
 247                                 write "\t: public virtual Root"
 248                         else for s in [c.supers.first] do
 249                                 write "\t: public virtual {s}"
 250                         end
 251                         write "\{"
 252                         write "\tpublic: virtual int id() \{ return {c.id}; \}"
 253                         write "\};"
 254                 end
 255                 write "template<class E>"
 256                 write "class L: public virtual Root \{ public:"
 257                 write "\tE _item; virtual E item() \{ return _item; \} virtual void set_item(E i) \{ _item = i; \}"
 258                 write "\tL<E> *_next; virtual L<E> *next() \{ return _next; \} virtual void set_next(L<E> *n) \{ _next = n; \}"
 259                 write "\tL(E i, L<E> *n) \{ set_item(i); set_next(n); \}"
 260                 write "\};"
 261
 262                 write "L<Root*> *fill() \{"
 263                 write "\tL<Root*> *head = 0;"
 264                 for c in classes do
 265                         write "\tL<{c}*> *l{c} = new L<{c}*>(new {c}(), 0);"
 266                         write "\thead = new L<Root*>(l{c}, head);"
 267                 end
 268                 write "\thead = 0;"
 269                 write "for (int x=0; x<{arraylen}; x++) \{"
 270                 for i in [0..listlen[ do
 271                         var c = unlist[i]
 272                         write "\tL<{c}*> *l{i} = new L<{c}*>(new {c}(), 0);"
 273                         write "\thead = new L<Root*>(l{i}, head);"
 274                 end
 275                 write "\}"
 276                 write "return head;"
 277                 write "\}"
 278
 279                 write "int run(L<Root*> *head1, L<Root*> *head2) \{"
 280                 write "\tint cpt = 0;"
 281                 write "\tint y = {loops/list.length};"
 282                 write "\twhile (y > 0) \{;"
 283                 write "\tL<Root*> *n1 = head1;"
 284                 write "\tL<Root*> *n2 = head2;"
 285                 write "\twhile (n1 != 0) \{"
 286                 for i in [0..listlen[ do
 287                         var c = list[i]
 288                         write "\t\tRoot *l{i} = n1->item();"
 289                         write "\t\tL<{c}*> *lc{i} = dynamic_cast<L<{c}*>*>(l{i});"
 290                         write "\t\t{c} *c{i} = lc{i}->item();"
 291                         write "\t\tn1 = n1->next();"
 292                         if count then
 293                                 write "\t\tif (c{i}->id() == {c.id}) cpt += 1;"
 294                         end
 295                         write "\t\tRoot *l2_{i} = n2->item();"
 296                         write "\t\tL<{c}*> *lc2_{i} = dynamic_cast<L<{c}*>*>(l2_{i});"
 297                         write "\t\tlc2_{i}->set_item(c{i});"
 298                         write "\t\tn2 = n2->next();"
 299                 end
 300                 write "\t\}"
 301                 write "y -= 1;"
 302                 write "\}"
 303                 write "return cpt;"
 304                 write "\}"
 305
 306                 write "int main(int argc, char **argv) \{"
 307                 write "L<Root*> *head = fill();"
 308                 write "int loops = 25;"
 309                 write "if (argc > 1) loops = atoi(argv[1]);"
 310                 write "for (int x=0; x<loops; x++) \{"
 311                 write "\tint cpt = run(head, head);"
 312                 write "\tstd::cout << x << \":\\t\" << cpt << std::endl;"
 313                 write "\}"
 314                 write "\treturn 0;"
 315                 write "\}"
 316                 file.close
 317         end
 318         fun writee(name: String, se: Bool)
 319         do
 320                 var istk = ""
 321                 if se then istk = " is"
 322
 323                 name.mkdir
 324                 file = new OFStream.open("{name}/root.e")
 325                 write "class ROOT"
 326                 write "feature id: INTEGER {istk} do Result := 0 end"
 327                 write "end"
 328                 file.close
 329
 330                 for c in classes do
 331                         file = new OFStream.open("{name}/{c}.e")
 332                         write "class {c} "
 333                         if c.supers.is_empty then
 334                                 write "\tinherit ROOT"
 335                         else for s in [c.supers.first] do
 336                                 write "\tinherit {s}"
 337                         end
 338                         write "\t\tredefine id end"
 339                         write "feature"
 340                         write "\tid: INTEGER {istk} do Result := {c.id} end"
 341                         write "end"
 342                         file.close
 343                 end
 344
 345                 file = new OFStream.open("{name}/l.e")
 346                 write "class L[E]"
 347                 write "inherit ROOT"
 348                 write "create make"
 349                 write "feature"
 350                 write "\titem: E"
 351                 write "\tset_item(i: E) {istk} do item := i end"
 352                 write "\tnext: L[E]"
 353                 write "\tset_next(n: L[E]) {istk} do next := n end"
 354                 write "\tmake(i: E; n: L[E]) {istk} do set_item(i); set_next(n); end"
 355                 write "end"
 356                 file.close
 357
 358                 file = new OFStream.open("{name}/app{name}.e")
 359                 write "class APP{name.to_upper}"
 360                 if se then
 361                         write "insert ARGUMENTS"
 362                 end
 363                 write "create make"
 364                 write "feature"
 365                 write "fill: L[ROOT] {istk}"
 366                 write "local"
 367                 write "\ti: INTEGER"
 368                 write "do"
 369                 for c in classes do
 370                         write "\tcreate Result.make(create \{L[{c}]\}.make(create \{{c}\}, Void), Result)"
 371                 end
 372                 write "\tResult := Void;"
 373                 write "from i := 0 until i >= {arraylen} loop"
 374                 for i in [0..listlen[ do
 375                         var c = unlist[i]
 376                         write "\tcreate Result.make(create \{L[{c}]\}.make(create \{{c}\}, Void), Result)"
 377                 end
 378                 write "i := i + 1"
 379                 write "end"
 380                 write "end"
 381
 382                 write "run(head1: L[ROOT]; head2: L[ROOT]): INTEGER{istk}"
 383                 write "local"
 384                 write "\ty: INTEGER"
 385                 write "\tn1, n2: L[ROOT]"
 386                 for i in [0..listlen[ do
 387                         var c = list[i]
 388                         write "\t\tl{i}: ROOT"
 389                         write "\t\tlc{i}: L[{c}]"
 390                         write "\t\tc{i}: {c}"
 391                         write "\t\tl2_{i}: ROOT"
 392                         write "\t\tlc2_{i}: L[{c}]"
 393                 end
 394                 write "do"
 395                 write "\tfrom y := {loops/list.length}"
 396                 write "\tuntil y <= 0"
 397                 write "\tloop"
 398                 write "\tfrom"
 399                 write "\tn1 := head1"
 400                 write "\tn2 := head2"
 401                 write "\tuntil n1 = Void loop"
 402                 for i in [0..listlen[ do
 403                         var c = list[i]
 404                         write "\t\tl{i} := n1.item"
 405                         write "\t\tlc{i} ?= l{i}"
 406                         write "\t\tc{i} := lc{i}.item"
 407                         if count then
 408                                 write "\t\tif c{i}.id = {c.id} then Result := Result + 1 end"
 409                         end
 410                         write "\t\tl2_{i} := n2.item"
 411                         write "\t\tlc2_{i} ?= l2_{i}"
 412                         write "\t\tlc2_{i}.set_item(c{i})"
 413                         write "\t\tn1 := n1.next"
 414                         write "\t\tn2 := n2.next"
 415                 end
 416                 write "end"
 417                 write "y := y - 1"
 418                 write "end"
 419                 write "end"
 420
 421                 if se then
 422                         write "make{istk}"
 423                 else
 424                         write "make(args: ARRAY[STRING]){istk}"
 425                 end
 426                 write "local"
 427                 write "head: L[ROOT]"
 428                 write "loops: INTEGER"
 429                 write "cpt: INTEGER"
 430                 write "x: INTEGER"
 431                 write "do"
 432                 write "head := fill"
 433                 write "loops := 25"
 434                 if se then
 435                         write "if argument_count > 0 then loops := argument(1).to_integer"
 436                 else
 437                         write "if args.count > 1 then loops := args.item(1).to_integer"
 438                 end
 439                 write "from x := 0 until x>=loops loop"
 440                 write "\tcpt := run(head, head)"
 441                 write "\tprint(x.out+\":%T\"+cpt.out+\"%N\")"
 442                 write "\t x := x + 1"
 443                 write "end"
 444                 write "end"
 445                 write "end"
 446                 write "end"
 447                 file.close
 448         end
 449
 450         var count = false
 451 end
 452
 453 var g = new Generator
 454 var name = args.first
 455 if args.length > 1 then
 456         var opts = args[1].split_with("_")
 457         for opt in opts do
 458                 var oname = opt.substring(0,1)
 459                 var val = opt.substring_from(1).to_i
 460                 if oname == "l" then
 461                         g.listlen = val
 462                 else if oname == "w" then
 463                         g.width = val
 464                 else if oname == "h" then
 465                         g.height = val
 466                 else
 467                         print "Option inconnue '{oname}'"
 468                         exit(1)
 469                 end
 470         end
 471 end
 472 g.genhier
 473 g.writenit(name)
 474 g.writejava(name, true)
 475 g.writecpp(name)
 476 g.writee("{name}_se", true)
 477 g.writee(name, false)