Review, Selection, Development, Application of Virtual Machine Platform(s)/Language(s)/Compilers for Code Generation and Language-Embedding for Automatic Programming, Code Synthesis, Program Generation, Intermediate Representations Lowering: KidVM, .NET CLR, JVM, LLVM, Zig, C, WebAssembly, Julia, Lua, Python, x64/x86 ASM, C++ ...?

[Twenkid]

The AGI infrastructure is supposed to include Automatic Programming/Automatic Program Learning/Self-Programming, Code Synthesis etc. capabilities.

That is related ideas about directions for a direction that I call "Информатика на развитието", or Developmental Informatics/Developmental Computer Science.

There are unpublished ideas, plans, notes, diagrams and thoughts, some experimental small VM/interpreter/compiler projects, which I wish to materialize and start implementing with this infrastructure.

I will unveil more of the ideas and the goals in the future with their implementation.

Current short evaluation (28.1.2023):

• Java vs .NET: JVM seems more complex than CLR, also C# can easily produce .dll and to interoperate with other DLLs etc. Current main working environment is Windows anyway, and there's Mono for other platforms.
• C and an old-fashioned-style C++ are an option for straightforward generation and call of DLLs and exes.
• LLVM and Clang - good for the above and for a multi-platform targeting; Clang also has a JIT compiler module, JITLink: https://llvm.org/docs/JITLink.html
• Julia had a module for interoperability with C++ which is obsolete with modern versions (Julia 1.3 or 1.4, a single-digit LLVM)
• There's a Python-C++ binding module with Cling: https://github.com/wlav/cppyy/blob/master/README.rst
• Python embedding in C++ is supposed to be straightforward: To Do* https://medium.datadriveninvestor.com/how-to-quickly-embed-python-in-your-c-application-23c19694813 https://docs.python.org/3/extending/embedding.html Etc.
• Lua also is used for easy script integration, try it as well. To Do! At first glance Python seems a better choice if the goal is to has access to the rich set of Python libraries
• WebAssembly is perspective for easier "crowd running" on browsers.
• "Bare metal" x86 Assembly to NASM, MASM is interesting and gives a warming bottom-up incremental touch with the machine, however probably it may be more complex than the other solutions and need more time to start it up. A code generation system that builds itself is supposed to start coding from the lowest level up, but it could start on some higher level ground, understand the world and then "lower" its representations down. Of course, in all cases there should be some sandboxing and protection.
• Zig is an interesting new language with interoperability with C: https://ziglang.org/
• KidVM is a custom educational "virtual machine", developed ad-hoc as an experiment in 2013 in classic C++ on Win32. There were some experiments with simple trampoline interpretation gluing with Windows functions - an Assembly code for the machine, compiled by the Assembler, run by the machine, calling Windows functions, interacting with a Win32 message loop and reacting to mouse events etc. There was also automatic collection of the constants from the Windows source code.

One thing that can be done in this train of thought is to extend KidVM or remake it properly with the intent to serve as a special code generation framework and for that purpose - to get extended with respectively crafted low level instructions for that and turn into a "code generation processor": CGP, and not an ordinary one. That system may generate code on some of the other languages in order to be compiled by the other infrastructures.

Of course, the serious VM and compilers are quite powerful "CGPs", given a source code and languages at their level. This one couldn't win in their game and could just utilize them.

A point where the hypothetic new VM could be better would be to interpret, translate, map, represent, compile, "lower"* other type of code from other structures, yet missing, not just the well established programming languages and AST. These structures and their hierarchical, transformational and graphical parsing would be more important for an AGI reasoning, generalization, search etc. system than the specific lower level languages, loop optimizations, vectorization etc. at the end of the pipeline.

KidVM's "instruction set architecture" could evolve or there could be a spin-off "CGP".
Currently it's a simple low level CPU with some calls of external functions. The Assembly code was the exact identifiers, mnemonics of the instructions, in order to translate them directly. As new instructions were gradually added ad-hoc, the Assembly compiler read and parsed the opcodes from the header file.

To be continued...

References

What is Lowering?

• https://stackoverflow.com/questions/20252876/wanted-good-definition-of-the-term-lowering-in-the-context-of-compilers
• Chapter 6: Lowering to LLVM and CodeGeneration: https://mlir.llvm.org/docs/Tutorials/Toy/Ch-6/
• https://mattwarren.org/2017/05/25/Lowering-in-the-C-Compiler/
• https://arxiv.org/abs/1805.00907 Glow: Graph Lowering Compiler Techniques for Neural Networks

[Twenkid]

The first choice for embedding and sandboxing in C++ seems to be Python:

//MSVC, Project, Options --> ... C++ -- Additional Include Directories: 
//Python path... /Include
//e.g. C:\Users\toshb\AppData\Local\Programs\Python\Python39\
//C:\Users\toshb\AppData\Local\Programs\Python\Python39\include
//C:\Users\toshb\AppData\Local\Programs\Python\Python39\Libs
// ... Libs //Python39.lib, Python 310.lib etc.

#include "Python.h" 
//...
void python() { //#30-1-2023
    std::cout << "py?";
    string modules_path = "z:\\";
    //Initialize the python instance
    Py_Initialize();
    PyObject* sysPath = PySys_GetObject((char*)"path");
    PyList_Append(sysPath, (PyUnicode_FromString(modules_path.c_str())));

    PyRun_SimpleString("from time import time,ctime\n"
        "print('Today is',ctime(time()))\n");

    //Run a python function
    PyObject* pName, * pModule, * pFunc, * pArgs, * pValue;
    pName = PyUnicode_FromString((char*)"testlib");
    pModule = PyImport_Import(pName);
    pFunc = PyObject_GetAttrString(pModule, (char*)"test"); //func
    pArgs = PyTuple_Pack(1, PyUnicode_FromString((char*)"Greg"));
    pValue = PyObject_CallObject(pFunc, pArgs);
    auto result = _PyUnicode_AsString(pValue);
    std::cout << result << std::endl;

    PyRun_SimpleString("def g1(c):\n  a=c/43; b=a*a; print(b)\n"
        "g1(464);\n"
        "print('Today is',ctime(time()))\n");

}

[Twenkid]

Java: JNI & FFM - Foreign Function and Memory API

31.1.2023: I am updating my Java knowledge and skills, tonight I began a quick review and crash course in the updates since Java 8, I was watching some of them in the past, 8 in particular, but I was an active Java developer before that and considered most of the new features as mostly "syntactic sugar" (starting with the lambdas etc.)

Regarding this strategic topic for language embedding and interoperability, in the new refresh I took a quick look at JNI - the Java Native Interface, used to call C/C++ DLLs.

I notice that in the recent Java versions a new more robust model is introduced, called "Foreign Function and Memory API": https://openjdk.org/jeps/424 The FFM API is released in the most recent Java 19, being "incubated" since several earlier revisions.

It may come in handy.

As of Java in general, it's fun. For now I use Eclipse.

2.2.2023: Since Java 16: JEP 389 - Foreign Linker API (Incubator) − Java code can be called by C/C++ or vice versa using new API replacing the JNI. It's been then part of /merged to the FFM API.

An example of Java-C interop and glue code from the docs: https://openjdk.org/jeps/424

// 1. Find foreign function on the C library path
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle radixSort = linker.downcallHandle(stdlib.lookup("radixsort"), ...);
// 2. Allocate on-heap memory to store four strings
String[] javaStrings   = { "mouse", "cat", "dog", "car" };
// 3. Allocate off-heap memory to store four pointers
SegmentAllocator allocator = SegmentAllocator.implicitAllocator();
MemorySegment offHeap  = allocator.allocateArray(ValueLayout.ADDRESS, javaStrings.length);
// 4. Copy the strings from on-heap to off-heap
for (int i = 0; i < javaStrings.length; i++) {
    // Allocate a string off-heap, then store a pointer to it
    MemorySegment cString = allocator.allocateUtf8String(javaStrings[i]);
    offHeap.setAtIndex(ValueLayout.ADDRESS, i, cString);
}
// 5. Sort the off-heap data by calling the foreign function
radixSort.invoke(offHeap, javaStrings.length, MemoryAddress.NULL, '\0');
// 6. Copy the (reordered) strings from off-heap to on-heap
for (int i = 0; i < javaStrings.length; i++) {
    MemoryAddress cStringPtr = offHeap.getAtIndex(ValueLayout.ADDRESS, i);
    javaStrings[i] = cStringPtr.getUtf8String(0);
}
assert Arrays.equals(javaStrings, new String[] {"car", "cat", "dog", "mouse"});  // true

[Twenkid]

• Checking Python embedding in C# - PythonNet. It allows advanced embedding even in the reverse direction, C#/CLR objects in Py, but that seems less practical. https://pythonnet.github.io/pythonnet/dotnet.html

• The Py embedding is a candidate for applying in ACS, my in-house "Research Assistant", or a "Cognitive Accelerator", and a Human-Computer Interaction testbed, which perhaps would be one of the early interfaces to the search engine/information retrieval and the AGI infrastructure that is been designed in this project.

One of the major recent implemented additions to ACS in 2022 was the introduction of a WebView2 control and ongoing extensions and experiments with custom interfaces to it. It is planned to grow to a complete browser for faster and smarter browsing, search, display, connected to the cognitive acceleration system. (...)

WebView2 is a modern web browser control, based on Edge. ACS had a browser years ago, but previously the "Assistant" used the original .NET web control, which had a very old rendering engine - IE6 or IE7? (...)

https://learn.microsoft.com/en-us/microsoft-edge/webview2/