Toward A Lingua Franca For Intelligent System Design

As the EDA industry is moving up further and further towards the intelligent design of full systems, this year’s Forum on Design Languages (FDL) offered a great update on the status quo with regard to where languages fit into this transition. It looks like the next step will not be one universal language as previously targeted back when there was a flurry of introductions of new programming models during the “multi-core crisis” in about 2005. Instead a meta language, like the “lingua franca” proposed by UC Berkeley, could be the next step, building on and integrating existing programming languages, rather than building a new universal one.

FDL took place in Southampton this year. I was invited to present and talk on a panel on “Application of EDA Models and Languages to Industry 4.0”, where we had an interesting discussion on how SystemC fits into system design and how extensions like SystemC AMS could be adopted. But my main takeaway from FDL was about the next step of design language development.

Almost 15 years back—in March 2005—Herb Sutter, who was at Microsoft at the time, published his now famous paper, “The Free Lunch Is Over,” predicting nothing less than a concurrent programming revolution as big as the object-oriented revolution. With processor architectures running out of room with traditional approaches to boosting CPU performance, higher clock speeds and ever higher instruction throughput were no longer the answer. Instead, hyperthreading and multicore architectures were emerging. Multicore devices were the big theme of the 2004 In-Stat/MDR Fall Processor Forum and Herb stated that “Looking back, it’s not much of a stretch to call 2004 the year of multicore.” Concurrency would be the next major revolution in how we write software.

What followed was a classic EDA tale. Pretty much every pitch predicted that the world would come to an end if we would not adopt specific programming models to enable concurrency. Some references from that time are “Software Standards for the Multicore Era,” which I co-authored, as well as the chapter on multicore architectures that I contributed to Bryon Moyer’s book, Real-World Multicore Embedded Systems.

Next to Herb Sutter’s paper, Professor Edward A. Lee’s “The Problem with Threads” was to me the most influential paper we all read at that time, basically arguing that threads are close to impossible to verify, that “Threads, as a model of computation, are wildly nondeterministic and the job of the programmer becomes one of pruning that nondeterminism.” Professor Lee was at FDL this year on a panel called “Systems of Systems Engineering—Where Will We Be in the Next 20 Years?” During a break, we reminisced a bit on his paper and the days of the multicore revolution. Professor Lee argued that the problems still do persist today in 2019, and the issue is now the “determinism of actors.”

This brings us back to the topic of a lingua franca for system design. Professor Lee’s PhD candidate, Marten Lohstroh, presented on the exact topic of determinism. He went all the way back to Kant’s “Ding an Sich” to define models as any description of a system that is not the “thing in itself”. Berkeley’s proposal of a lingua franca to deal with system modeling is an approach of coordination using ports, hierarchy and scheduling, making the design deterministic and addressing what Professor Lee had postulated as “the problem with threads”. The figure below shows a “Hello World” example.

Lingua franca “Hello World” example as proposed by UC Berkeley. Photo from Marten Lohstroh’s presentation at FDL.

What struck me as interesting and key is that the programming model really focuses on coordination and the atomic reactions can be written in existing languages. It’s incremental. All of this is combined with the vision of precision-timed (PRET) processors for performance and predictability. For the lingua franca (more information can be found on the GitHub Lingua Franca Wiki), time is a first-class citizen, while nondeterminism must be introduced explicitly using actions. Marten actually presented their work on a compiler and runtime API they built that allows for the reading of inputs, writing of outputs and scheduling of actions. The compiler itself is relatively simple as code optimization is left to the target language compiler. New target languages can be added relatively easily by writing a runtime and code generator.

So, it turns out that 15 years after the multicore crisis, the industry has made significant strides towards concurrency in programming languages, and the proper handling of determinism is definitely on the horizon.

Exciting times ahead for system design!