Handle discussion

[cpurdy]

service "shapes":
protoservice - a local object that has not left the service within which it was created (or
               into which it was first injected, in the case of some native services)
unconservice - a service that is used exclusively by one service at a time, but which has not
               encountered contention, and thus is optimized for release-on-demand (batch-optimized)
synchservice - a service that has encountered contention, and thus has been de-optimized to use
               lock-based ownership
queueservice - a high contention and/or backlogged service that has de-optimimzed to a queue
               processor in order to minimize access contention

object pointer size
  64-bit word
  41-bit address info (32TB with 16-byte alignment)
  42-bit pointer data
  18-bit type info (up to 262,144 type ids within a given type-system scope)

4-bit code (e.g. bit 0-3)
  0000 pointer (i.e. not a fat pointer, 16 byte alignment)
  0001 Int
  0010 UInt
  0011 Dec
  0100 <-- this value means that the 60 bits is divided into a 28 bit type info and 32 bit value
  0101 Range 0..<Int
  0110 Range 0..<UInt
  0111
  1000
  1001 [Int]
  1010 [UInt]
  1011 [Dec]
  1100
  1101 (Int)
  1110 (UInt)
  1111 (Dec)

what is the type of the reference?
  struct     00
  public     01
  protected  10
  private    11

Dec
  50 bit signed int value (0 for special values)
  10 bit scalar, includes special values:
    +zero, +nan, +signan, +infinity, -zero, -nan, -signan, -infinity

Int
  60

Range 0..n 0..<n
String
Char[]
Byte[] & reversed
Bit[] & reversed

-- other --
Range n1?..?n2 (inclusive vs. exclusive on both ends)

Null
Boolean
- True
- False

Char
String
 - 0 length
 - 1 ASCII char
 - 2 ASCII char
 - 3 ASCII char
 - 4 ASCII char
 - 5 ASCII char
 - 6 ASCII char
 - 7 ASCII char
 - 8 ASCII char

 - 1-8 ASCII char
 - 2char
 - ...

Ordered
 - Lesser
 - Equal
 - Greater


Assumptions:
* Everything in Ecstasy is a reference type ("everything is an object", even when it's not).
* Code gen aggressively replaces known immutable value types (Int, Boolean, etc.) with native types.
* For each Ecstasy function, there exists a native function which takes arguments and returns values as universally coded references, aka fat pointers (either a pointer to a standard object layout that includes a pointer to its class, or sufficient data to represent the "object" jammed into the space that the pointer would have occupied).
* Additionally, other function _shapes_ can be generated, replacing some set of parameters/returns with the native versions thereof.
* The ability to fall back to thhe generic reference form is always assumed to be necessary (e.g. user could sub-class `Int` and use their `CustomInt` objects interchangeably with standard `Int` "objects", perhaps even placing some of both in an `Int[]`)

[cpurdy]

target runtime requirements:

1. ability to load new code on the fly
   a) examples

   • load and run a designated app
   • regex, debugger eval, etc.
     b) additional requirements
   • previously loaded code must be GC-able or explicitly evictable (significant amounts of code
     will be loaded millions of times, so it must be released and evicted somehow)
   • immediate term code mutation (inline cache example) is desirable, but in theory it is not
     required (since a new version of code can be loaded and the old version can be discarded)

2. threading and concurrency ,

   • must be able to consume all cores of the machine with concurrently executing code
   • concurrent code must be able to safely interact, as defined by Ecstasy services
   • ideally, the machine "shape" (# cores, perf/efficiency, etc., and RAM size) are available

3. fiber support

• must be able to suspend execution of a fiber at any safe-point, retaining its execution stack
• must be able to kill a fiber (in order to be able to kill a service)
• basically, need a fiber.continue() method, and the ability of a fiber to call this.suspend()

4. service support

• depends on: concurrent execution support (Fix Hello World for Windows #2), with fiber support (adds ability to run services in parallel #3)
• exceptions must be able to generate stack traces across service boundaries

5. container support

• depends on: code loading (Link to Twitter profile #1), services (Welcome to the Ecstasy chat! #4)
• ability to dynamically form and load a type system
• ability to store a snapshot of a paused container persistently, and later restore that image

6. I/O support

• basic I/O abstraction (e.g. console) available
• file system abstraction available
• network abstraction available
• GUI abstraction available (required only for client platforms)

7. debugging support

• mostly TBD
• containers must be debuggable independently, i.e. most containers will not be being "debugged",
  but one specific container may be being debugged by one user or connection, while another
  specific container may be being debugged by another user or connection
• expression evaluation, watches, code stepping, breakpoints, break-on-condition or
  break-on-change (including watches)
• debugging of Ecstasy code may be a feature in the require webassembly code reload to "enable"
• debugging may require a generated code reload to "enable"

assumptions:

1. total processors and memory to be specified or is determinable

Possible platforms:

1. Java

2. Javascript

3. WebAssembly

3(b). "custom" WebAssembly

3(c). Javascript+WebAssembly

4. LLVM

[cpurdy]

    interface Convert
        {
        Int convert(String s);
        }

    class Conv1
            implements Convert
        {
        Int n;
        // ...
        return n;
        }

    class Conv2
            implements Convert
        {
        Int n;
        // ...
        return n;
        }

    // somewhere
    Int foo(Matrix<String> m, Convert c)
        {
        Int n = 0;
        for (Int i = 0..10000000)
            {
            for (Int j = 0..100000000)
                {
                n += convert(m[i,j]);
                }
            }
        return n;
        }

    class Foov1
        {
        static int count;

        // Java form, step 1
        static Object NameMangledFoov1(int stackPos, byteBuffer params, byteBuffer rets)    // <- ABI
            {
            ++count; // stats

            // "tracing JIT"-like output
            long hMatrix_m = params[0];
            long hConvert_c = params[1];

            long hInt_n = makeInt(0);
            int loopcnt = 0;
            long hInt_i = makeInt(0);
            long hInt_iLimit = makeInt(10000000);
            while (true)
                {

                while (true)
                    {
                    // other translated code goes here

                    if (++loopcnt > 345781)
                        {
                        safepointCheck(Foov1.class, stackPos); // what else needs to be passed? anything returned?
                        loopcnt = 0;
                        }
                    }

                if (hInt_i.inc().isGT(hInt_iLimit))
                    {
                    break;
                    }

                }
            rets[0] = hInt_n;
            return Success;
            }
        }

    class Foov2
        {
        // add more stats etc.
        }

    // ...

    class Foov8
        {
        static Object NameMangledFoov1(int stackPos, byteBuffer params, int paramoffset, byteBuffer rets, int retoffsert)    // <- ABI
            {
            // this is mostly unused but has to exist
            if (params[0].isA(xMatrix.class) && params[1].isA(Conv2.class))
                {
                return NameMangledFoov1_opt(params[0], params[1])
                }

            // otherwise some less optimized code ...
            // ...
            }

        static Object NameMangledFoov1_opt(long hMatrix_m, hConvert_c)
            {
            // loop unrolling etc.etc.
            // ...
                {

                // inline this: array[index] = Conv2.NameMangledConvertv13(hstr);
                }

            // before calling safepoint(), "normalize" the fields to look just like NameMangledFoov1
            // ...
            }
        }