assets/developer-notes/stephanie-gawroriski/2016/06/27.mkd

   1 # 2016/06/27
   2
   3 ## 07:31
   4
   5 Sunday was a stressful day, so yesterday I spent the time healing up. So
   6 hopefully I can get some work done today.
   7
   8 ## 09:00
   9
  10 When it comes to generation, my plan for the compiler was to have it segmented
  11 into interfaces that provide specific functionality. This would allow the most
  12 patchable code generator which may be needed for specific systems. Essentially
  13 there would be a basic PowerPC generator interface. Thinking about it, with
  14 the service loader I would then not require that the compiler bits are even
  15 extending off each other. So essentially the compilers would be sorted by
  16 architecture (and their variant). The base class would be a final
  17 `SSJITProducer`. The producer would be given interfaces which all extend from
  18 a base interface. Following this, the producer factory would have a
  19 contributing generator fragment which implements a number of interfaces for
  20 added functionality. When the generator is called to generate some code, it
  21 will then call through premapped interfaces that perform actual code generation
  22 for the most part. Then this way there can be a base PowerPC provider. Then
  23 there would be a Linux variant for PowerPC (likely sysv). The Linux variant
  24 would just extend `SSJITProducerFactory` for the factory and the actual
  25 generator with its implemented interfaces would implement `SSJITProducer`.
  26
  27 ## 09:09
  28
  29 Actually, the producer is final so the factory would provide the set of
  30 interfaces. The interface set would then have a bind to the given producer.
  31 This way when something needs to be done, it can call into the given producer
  32 so that if there is another potential variant that it can be handled
  33 properly.
  34
  35 ## 09:14
  36
  37 These interfaces would be called functions. I can either share them between
  38 or have them completely alone. Being alone would add to the memory cost and
  39 increase garbage collection costs, however it would simplify code generation
  40 because each instance of a function could have its own set of variables.
  41
  42 ## 09:18
  43
  44 Then this means that `SSJITProducerFactory` is renamed and turned into
  45 `SSJITFunctionFactory`.
  46
  47 ## 09:20
  48
  49 So this also means that in the event of floating point, I can have a fallback
  50 software floating point factory which can actually be enforced. So even if the
  51 PowerPC function set would natively support floating point, the factory can
  52 just be given a software floating point function that has higher priority.
  53
  54 ## 09:22
  55
  56 For 8-bit and 16-bit systems, I can even have a function that handles higher
  57 bit operations by wrapping them in the smaller operation functions. So instead
  58 of rewriting 32-bit/64-bit math functions in each set of functions, I only
  59 have to do it once. However, I could just have a base class that handles these
  60 operations natively.
  61
  62 ## 09:34
  63
  64 Also, this means that CPU variants can more easily be supported. Very old
  65 PowerPC CPUs do not support SIMD operations. So on variants that support
  66 AltiVec for example, I can have a standard PowerPC function returned along with
  67 an AltiVec function.
  68