assets/developer-notes/stephanie-gawroriski/2014/11/19.mkd

   1 # 2014/11/19
   2
   3 ***DISCLAIMER***: _These notes are from the defunct k8 project which_
   4 _precedes SquirrelJME. The notes for SquirrelJME start on 2016/02/26!_
   5 _The k8 project was effectively a Java SE 8 operating system and as such_
   6 _all of the notes are in the context of that scope. That project is no_
   7 _longer my goal as SquirrelJME is the spiritual successor to it._
   8
   9 ## 02:06
  10
  11 Had this idea, the ClassBus and ClassIdentity (or whatever) is a bad idea.
  12 What I need is a single class in the logical area with a sub interface. The
  13 class can be called WhichClass and provides the means for potentially looking
  14 for classes that are dependencies of compilation. Since the call table for
  15 other classes must be determined before any native code is generated for them.
  16 This is why the classes will have a checksum based dependency system. No,
  17 forget that. The dependencies of methods can be determined at link time so the
  18 class will just have an import and export table, super class stuff would also
  19 be determined then also (if a class calls a non-static method in its far down
  20 superclass it will pretty much be a link back to self if it is not final or if
  21 it does not have such method it will correctly point to the superclass one).
  22 When first compiling a class, due to field volatile potential it would be
  23 unknown if a getfield or putfield should synchronize memory. So perhaps using
  24 some nop hacks I can instead have it so there is a potential for it to be
  25 volatile and if it really is not volatile then to just wipe out the machine
  26 code that synchronizes memory. However, one thing though is that it might only
  27 have to be done on volatile putfields. Because if other CPUs have a changed
  28 value in their cache for that field then a memory sync after a put would be
  29 enough before other CPUs read the value. That should statisfy the order
  30 whatever. That is, happens before something else. Although I would have to
  31 read up more on the CPU to determine this as it could vary. So I will need a
  32 possible sync before a field read or one after a field set and it could vary
  33 on the CPU. Though I could add code destroyers if the field is not volatile at
  34 all so when the native class is loaded it gets NOPed away. That would be the
  35 simplest solution as I would no longer need to load all of these classes just
  36 to figure out how to access a field, so that saves time so I no longer need to
  37 potentially load the entire class library at once.
  38
  39 ## 13:43
  40
  41 Ok, so I need a good way to initialize SSA operations as I construct the code
  42 from the byte code.
  43
  44 ## 19:37
  45
  46 All methods will have an intro and an endtro, the intro does basic stuff if
  47 needed (such as synchronized methods) and the endtro also frees the lock on
  48 exit. The endtro would also clean up any final references to things. I will
  49 want to have a new (for objects) that is capable of spawning objects in the
  50 heap or on the stack (depending on visibility and such) and then in the final
  51 cleanup for a method it can lower the reference count if it is in the heap or
  52 destroy the object completely if it resides on the stack. Introductions to
  53 areas that are capable of being exception handled will have to have their own
  54 endtros also to lower the count of any references that were lost when the
  55 exception was thrown.
  56
  57 ## 20:17
  58
  59 Perhaps on the leave of a method there can be a method object reference table
  60 that is ran through to clear up any old references.
  61
  62 ## 20:37
  63
  64 Actually, I can have two stacks, the normal method stack and the referenced
  65 object stack. When the method ends it goes through the object stack and lowers
  66 the reference count and if it is zero it clears it. The only objects that get
  67 added there are ones that are on the heap and not the stack. Also for optimize
  68 of new, each method will need a hint as to what it does with the argument (if
  69 it is an object). That hint could propagate to callers of the method when they
  70 perform the actual new. The hints would be simple such as Stack or Heap. A
  71 heap can never get downgraded to a stack but a stack could be upgraded to a
  72 heap. At linking time it is determined how an object should act based on its
  73 exposure status. It would completely depend on stuff like the super class so
  74 when I design all of my classes I must avoid this references being set to
  75 fields and such. So a method could allocate an object which it never sets to a
  76 field and never externally exposes. Now it all depends on the object, whether
  77 it exposes itself (or potentially can do it). Exposure is pretty much getting
  78 assigned to a field or an array. However the array can vary because if the
  79 array itself is not exposed then all of its members do not get upgraded,
  80 however if the array is exposed then all the members that are added to it must
  81 get their exposure set. The byte code compiler would perform basic work while
  82 the SSA optimization system would determine object exposures and such.
  83
  84 ## 23:25
  85
  86 Currently going to setup Jenkins for automated building and testing so that
  87 way I can test a bunch of things.
  88