What does HackerNews think of omr?

Eclipse OMR™ Cross platform components for building reliable, high performance language runtimes

Language: C++

#93 in Hacktoberfest
Thank you.

There is also OMR

https://github.com/eclipse/omr

but I'm not sure how powerful that is.

I started writing a simple multithreaded interpreter that processes an imaginary assembly. Here's a program in that imaginary assembly that sends integers to other threads and then sends a jump instruction to another thread to jump to some code. It uses an pseudo actor implementation I wrote that can send 20-100 million messages between threads a second. When sending a single integer at a time it's a lot slower and can only send 1.7 million messages a second due to overhead of the interpreter. Switch interpreters aren't fast such as deegen or Java's template interpreter or V8

  threads 25
  
  mailbox numbers
  mailbox methods
  set running 1
  set current_thread 0
  set received_value 0
  set current 1
  set increment 1
  :while1
  while running :end
  receive numbers received_value :send
  receivecode methods :send :send
  :send
  add received_value current
  addv current_thread 1
  modulo current_thread 25
  send numbers current_thread increment :while1
  sendcode methods current_thread :print
  endwhile :while1
  jump :end
  :print
  println current
  return
  :end

I then started writing a parser for a high level language and then code generation from the AST to the imaginary assembly. My interpreter is multithreaded and can send integers between interpreters. It is very early and doesn't do much.

Code is at https://github.com/samsquire/multiversion-concurrency-contro...

The high level language looks similar to Javascript except I tried to parse everything as an expression. I need to change the parser to parse functions as expressions.

I was experimenting with Protothreads in C recently to try understand how it worked and I wrote a giant switch statement and a while loop in Java to simulate async/await. It would be interesting to do codegen for coroutines.

here's that giant switch statement and scheduler https://github.com/samsquire/multiversion-concurrency-contro...

One idea for a stackless design I had was to preallocate memory for each method call referenced by a method for a call to that function and avoid a stack altogether. This would allow coroutines between methods and avoid the function colour problem because everything is a coroutine.

Is there any communities for programming language developers? Where do all the language developers meet up and talk theory and implementation? I am on eatonphil's discord and we talk there.

One problem I am trying to understand how to solve is how you would write a multithreaded interpreter and language that allowed parallel interpretation similar to C# and Java. If the allocator is thread safe and you share an object pool between interpreters and you hash object equality by sourcecode, then you could send objects between threads with only a synchronization cost.

I believe Python has the problem that object identity is different in each subinterpreter so you need to marshall the data.

I am interested in this too. I would do different tradeoffs. I am more interested in optional garbage collection, the parallelism and async story in the language such as threading and coroutines or both together.

I suspect combining garbage collection, exceptions, closures, tail call optimisation, parallelism, JIT compilation and coroutines is difficult to do orthogonally.

On eatonphil's discord someone recently shared this link: This is a framework for building high performance language runtimes

https://github.com/eclipse/omr

I am currently implementing a programming language and compiler and interpreter in my multiversion-concurrency-control repository.

https://github.com/samsquire/multiversion-concurrency-contro...

I am doing codegen that is interpreted by my imaginary interpreter. My assembly has primitives for thread safe multithreading.

The OMR project gave Ruby and Python a try, Ruby was up and running to a decent point. Python turned out much harder.

The Ruby community went in different direction here [2] with RTL MJIT.

[1] https://github.com/eclipse/omr [2] https://medium.com/square-corner-blog/rubys-new-jit-91a5c864...

PSA: If there are folks writing their own JIT languages (and are highly encouraged to do so) please also checkout out the Eclipse OMR project. OMR is a bunch pluggable runtime components (GC, JIT etc...) intended to ease building of runtimes from scratch.

https://github.com/eclipse/omr

IBM Canada | Eclipse OMR Developer | Toronto, ON | Full-time, ONSITE | https://ibm.biz/BdsBQD

The IBM Runtime Technologies team is looking to hire motivated software developers to join our mission to nurture an open source community around the Eclipse OMR toolkit for language

runtimes (https://www.eclipse.org/omr).

We develop the Just-In-Time compiler for various language runtimes (Java, JavaScript, Python, Ruby etc.) built on Eclipse OMR: https://github.com/eclipse/omr. The IBM runtime compiler team

also ports and optimizes industry standard open runtimes such as Google V8 and Node.js. We contribute industry-leading performance and capabilities across multiple hardware platforms

(Intel, ARM, IBM Power and z Systems) and operating systems (Windows, Linux, AIX, z/OS).

We are looking for software developers comfortable in an environment that is predominantly C and C++ based, but also willing to go down to the assembly language level. Polyglot skills are

an asset, as we work in a variety of exhibited scripting languages.

We want to hear from you, please apply here: https://ibm.biz/BdsBQD

Hey, OMR developer here.

Ruby+OMR is developed in three pieces: 1) the language independent core, then 2) The language dependent portions (i.e., the VM, and what we call the 'glue')

The language independent core is here: https://github.com/eclipse/omr. It's under active development, :)

I'm actually working on Ruby 2.4 support right now (supremely not prime time, but if you're curious, the branch is here: https://github.com/mgaudet/ruby/tree/ruby_2_4_omr_preliminar...)

"About GC: it would be nice if there would be some kind of standard-ish implementation framework for a GC in an LLVM language."

Not quite LLVM, but take a look at the Eclipse OMR project.

OMR intends to provide a set of reuseable components like a GC, port-library and given more effort a jit to be reused into existing language runtimes or build a whole new language out of them.

https://github.com/eclipse/omr