Magnus Björk

FlexCore: Utilizing Exposed Datapath Control for Efficient Computing

rdquoWe introduce FlexCore, the first exemplar of an architecture based on the FlexSoC framework. Comprising the same datapath units found in a conventional five-stage pipeline, the FlexCore has an exposed datapath control and a flexible interconnect to allow the datapath to be dynamically reconfigured as a consequence of code generation. Additionally, the FlexCore allows specialized datapath units to be inserted and utilized within the same architecture and compilation framework. This study shows that, in comparison to a conventional five-stage general-purpose processor, the FlexCore is up to 40% more efficient in terms of cycle count on a set of benchmarks from the embedded application domain. We show that both the fine grained control and the flexible interconnect contribute to the speedup. Furthermore, according to our VLSI implementation study, the FlexCore architecture offers both time and energy savings. The exposed FlexCore datapath requires a wide control word. The conducted evaluation confirms that this increases the instruction bandwidth and memory footprint. This calls for efficient instruction decoding as proposed in the FlexSoC

A Flexible Datapath Interconnect for Embedded Applications

We investigate the effects of introducing a flexible interconnect into an exposed datapath. We define an exposed datapath as a traditional GPP datapath that has its normal control removed, leading to the exposure of a wide control word. For an FFT benchmark, the introduction of a flexible interconnects reduces the total execution time by 16%. Compared to a traditional GPP, the execution time for an exposed datapath using a flexible interconnect is 32% shorter whereas the energy dissipation is 29% lower. Our investigation is based on a cycle-accurate architectural simulator and figures on delay, power, and area are obtained from placed-and-routed layouts in a commercial 0.13-mum technology. The results from our case studies indicate that by utilizing a flexible interconnect, significant performance gains can be achieved for generic applications.

First Order Stålmarck

We present a proof method with a novel way of introducing universal lemmas. The method is a first order extension of Stålmarck’s method, containing a branch-and-merge rule known as the dilemma rule. The dilemma rule creates two branches in a tableau-like way, but later recombines the two branches, keeping the common consequences. While the propositional version uses normal set intersection in the merges, the first order version searches for pairwise unifiable formulae in the two branches. Within branches, the system uses a special kind of variables that may not be substituted. At branch merges, these variables are replaced by universal variables, and in this way universal lemmas can be introduced. Relevant splitting formulae are found through failed unifications of variables in branches. This article presents the calculus and proof procedure, and shows soundness and completeness. Benchmarks of an implementation are also presented.

A first order extension of stålmarck’s method

We describe an extension of Stalmarck’s method in First Order Logic. Stalmarck’s method is a tableaux-like theorem proving method for propositional logic, that uses a branch-and-merge rule known as the dilemma rule. This rule opens two branches and later merges them, by retaining their common consequences. The propositional version does this with normal set intersection, while the FOL version searches for pairwise unifiable formulae from the two branches. The proof procedure attempts to find proofs with as few simultaneously open branches as possible. We present the proof system and a proof procedure, and show soundness and completeness. We also present benchmarks for an implementation of the proof procedure.