Skip to content

Home

Jump to bottom
assyrianic edited this page Jul 27, 2018 · 60 revisions

Welcome to the Tagha Virtual Machine wiki! the Wiki is always being updated to account for iterative changes.

Purpose:

The purpose for Tagha's existence is to utilize C as an embeddable scripting language or, for better words, Tagha is an embeddable runtime environment meant to execute C code that's compiled to Tagha bytecode. Tagha was designed to be used as a viable alternative to a C plugin architecture via dynamically loaded dll's, especially with the advantage of being able to run C code without having to recompile the dll's for different operating systems and ABIs at the cost of native machine code performance.

Rationale:

You might be thinking, why not just pick a scripting language? You're correct. Any developer could simply choose a scripting language. If one wants a scripting language, one is free to embed it but not all developers want to use a scripting language and they could have various reasons like performance, syntax, maybe the runtime is too bloated. Secondly, not all developers might know the language or are comfortable with it.

Another idea you might think is that one could use a C interpreter and embed that but so far, the only C interpreters (that I currently know of) are CINT, PicoC, TCC [1], Cling and Ch:

  • The problems with CINT is that it's old, clunky to use, outdated, and deprecated.
  • PicoC is ok but its problem is that it uses old-school interpreting (just runs literal code) instead of compiling to bytecode which would allow it to execute faster.
  • Cling (developed by ROOT CERN) is very good in what it does but it creates a massive dependency called LLVM and Clang which can massively bloat your project's memory requirements and/or size.
  • The problem with Ch is that, though it's embeddable and updated, it's proprietary and it's unknown how it interprets code; as the usual problem with proprietary code, you don't know what code it could contain and there's no telling what security issues Ch could possibly have; not to mention that proprietary code shuts out enthusiastic individuals or groups from contributing to the software. UPDATE: I read on the Ch's developers website that Ch also interprets source code directly, doesn't use a bytecode machine! Specifically, Ch uses an AST-walking interpreter that's combined with a JIT Compiler [2], that'll speed up code but reduces significantly portability. [3]
  • [1] - Tiny C Compiler, it can compile and run scripts for testing but it can't be embedded the same way a scripting system can be.
  • [2] - citation from Ch dev website
  • [3] - Embeddable Ch is NOT free, you must get a price quote for it and purchase it.

The Rationale for Tagha is...

    1. give C (and by extension C++) binary portability.
    1. have the execution speed advantage that bytecode interpreters have over more traditional interpreters.
    1. be open-source.
    1. have a runtime environment without having dependencies (beyond libc of course)
    1. be portable and embeddable for any program and platform.
    1. be small and minimal.

Requirements:

  • C99 compliant C compiler.

Features

  • register-based virtual machine with 3 different addressing modes to tackle any kind of operation.
  • 22 general purpose registers + 3 reserved-use (stack pointers and instruction pointer) registers.12
  • self-contained.
  • has its own implementation of libc specially for TaghaVM.
  • floats and doubles are supported on the same floating point opcodes through addressing modes.
  • uses computed goto dispatches (the ones that use a void*) which is 20%-25% faster than a switch {citation}.
  • Tagha is "64-bit" as the registers and memory addresses are 64-bit. (will run slower on 32-bit systems/OSes)
  • Embeddable into host applications.
  • scripts can call host-defined functions (Native Interface).
  • host can give arguments and call script functions and retrieve return values, thus you can set up function event handling to scripts.
  • host can bind its own global variables to script-side global variables by name (the script-side global variable must be a pointer).
  • integer and float arithmetic, (un)conditional jumps, comparison operations, and stack and memory manipulations.
  • function call and return opcodes automatically execute function prologues and epilogues.
  • VM is little-endian format architecture.
  • very small. The runtime environment static library is only ~30kb.
  • Tagha is not natively threaded, this is by design, this is so any developer can thread Tagha in anyway you wish whether by having a single VM instance run multiple scripts in a multi-threaded, managed way OR have an array of Tagha VM instances each running their own scripts in a threaded manner.
  • Speed, tagha is very fast for a virtual machine that does not use a JIT.

VM Internals and Interaction

  • General rundown how a script gets made and then executed.

Clone this wiki locally