Fibers – blocking is cheap in a Parallel Universe jPrime 2017 Stefan Minev

Stefan Minev Software Developer

Quasar -  library that provides high-performance lightweight threads and actors for the JVM Quick overview Demo QA are during the demo and after it Private and confidential

At the beginning the threads were “Green”

What are fibers? Thread is a continuation scheduled to run on a CPU core at the appropriate time by a scheduler. Continuation is a program counter, marking a given point in the sequence of instructions, and a stack, storing the values of the variables. Quasar fibers are threads implemented in JVM bytecode rather than in the OS kernel.

Why fibers instead of OS threads? Threads are expensive: Thread switching incurs significant performance penalty. The kernel schedules threads by using a general-purpose scheduling algorithm. We can have only few thousands of them. Quasar fibers are cheap Fibers put a far lesser burden on the CPU when task-switching. Fibers are scheduled at the application layer by a high-quality work-stealing scheduler that uses fork join pool. Ideal for transactions that block very often. We can have millions of them - an idle fiber occupies ~400 bytes of RAM.

How do fibers work? new Fiber<>((SuspendableRunnable) () -> { // Instrumentation here - set bytecode index on resume long mills = System.currentTimeMillis(); System.out.println( "before suspension: " + mills); // Instrumentation here - store variables Fiber.sleep(3000); // Instrumentation here - restore variables System.out.println("and now on resume: " + mills); }.start(); before suspension: 1494491529024 and now on resume: 1494491529024

Identify suspendable methods to be instrumented Throws SuspendExecution exception in a method signature Add @Suspendable annotation to a method List classes/methods in suspendables and suspendable-supers files Use the SuspendablesScanner Ant task to fill the suspendable-supers file Use the SuspendablesScanner Ant task in auto mode to fill suspendables and suspendable-supers files without manually marking suspendable methods at all. Could end up instrumenting more than necessary.

Ways to perform the bytecode instrumentation Running the Instrumentation Java Agent (-javaagent:path-to-quasar-jar.jar as a JVM argument). This works with standalone Java applications and embedded Servlet containers. Ahead-of-Time (AOT) Instrumentation by running InstrumentationTask via Ant after compilation. Using QuasarWebAppClassLoader for standalone Servlet containers (Tomcat and Jetty).

Official caveats Runaway fibers – stuck in a loop or blocking the thread Thread locals in Fibers – works as expected Synchronized and blocking “Thread” calls – not allowed by default but could be handled

“Do not communicate by sharing memory; instead, share memory by communicating.” Channels - queues used to pass messages between strands (fibers and threads). ch: = make(chan string) go func() { ch < -"ping" }() msg: = < -ch fmt.Println(msg) Channel<String> ch = Channels.newChannel(0); new Fiber( ()-> ch.send("ping") ).start(); String msg = ch.receive(); System.out.println(msg);

Quasar’s Actor System Quasar provides an implementation of the actor model practically identical to Erlang’s. Akka’s callback-based API vs Quasar’s fiber blocking API

Comsat – your universe implemented with fibers Servlets – extending FiberHttpServlet instead of HttpServlet JAX-RS API –using the co.paralleluniverse.fibers.jersey.ServletContainer with enabled async support instead of the one provided by Jersey. HTTP clients - Apache Http Client, JAX-RS client, Retrofit and OkHttp DB access – JDBC, MongoDB, JDBI, JOOQ Dropwizard Spring – Spring Web MVC, Spring Boot, Spring Security Web Actors – it is a new API

Demo

Awesome! What’s the gain? Go on with your easy to write synchronous code and benefit from the power and efficiency of the asynchronous programming. Just leave the complexity in a Parallel Universe! Private and confidential

So…is it production ready and should I use it?

Let’s make Java great again! “Note: work is ongoing with the OpenJDK team that will allow to remove this restriction completely starting with a JDK9 version of Quasar: efficient, automatic runtime instrumentation will be performed at the bytecode level, that is for all code written in any JVM language, without need anymore for annotations nor instrumentation plugins.”

Questions?