Keleusma Research Spike: What a Verified Bound Says About the Code That Actually Runs

Erratum, 2026-08-12

The empirical sections of this article measured code that had never been optimised, and the corrected figures reverse the direction of the finding. The measurement invoked the back end at two optimisation levels over the same intermediate representation. The pass that promotes stack slots into registers is a middle-end pass and the back end does not run it, so both figures described unpromoted code and the difference between them was back-end noise.

Three claims made below are wrong and are corrected in place, with the original figures retained so the change is visible.

• The optimiser eliminates the provisioning, and does not relocate it into spill slots. Promoted then lowered, the same 19 modules occupy 5,048 bytes of frame against the 275,432 bytes reported here for unpromoted code, a factor of 54.
• The proven bound exceeds the real frame in every module measured, rather than falling short of it. The ratios run from 0.12 to 0.88. The article’s claim that this fails in the dangerous direction is the reverse of what happens.
• The provisioning change reported elsewhere as a large saving buys nothing for the shipped pipeline, since promotion had already removed the dead allocations.

This does not rescue the bound. Eight modules agree that it exceeds the frame and no mechanism guarantees that. The two quantities are in different units, count different things and are decided by different agents, so the agreement is coincidence and not construction. The supportable statement is that the bound is empirically conservative on this corpus under the shipped pipeline, which is much weaker than sound.

The structural contribution is unaffected, being the three-part split of the bound set out in Result 1, the literature survey, and the timing result with its stated weakness.

Somebody proves a program can never use more than a certain amount of memory. Then a compiler rewrites that program into a different form before it runs. Does the proof still apply?

The answer, for the system examined here, is that part of it does and part of it was never about the compiled program at all. The measurement that shows which is cheap and quick, which is the uncomfortable part. Nobody had run it.

This article is a case study of a mistake that is easy to make and hard to see. A property is established about one thing, and then claimed about a different thing, with a transformation standing between them that was never asked to preserve the property.

Written as a schema, with $\Phi$ the property, $A$ the thing it was established about and $\mathcal{T}$ the transformation, the mistake is to treat

as though it needed no argument. It always needs one, and the argument is a statement about $\mathcal{T}$ rather than about $\Phi$. Stated that baldly it sounds like nobody would make the mistake. In practice it is everywhere.

A performance budget measured in a staging environment and quoted for production. A power draw calculated from a circuit simulation and quoted for the manufactured board. A safety margin computed for a scale model and quoted for the full-size structure. In each case something in between changed the artefact, and in each case the question is whether it changed the thing being measured.

The specific case here is a programming language whose entire reason to exist is that it refuses any program whose time and memory it cannot bound in advance. That language grew the ability to compile down to machine code. Nobody had checked whether the bounds still mean anything once the code is machine code.

What You Need to Know to Read This

No compiler background is required, and this section is the reason that claim is true. Five ideas carry the whole article.

A program is written once and exists in several forms. The form a person writes, an intermediate form convenient for machines to reason about, and the final form the processor actually executes. The system here proves its guarantees about the middle form and ships the last one.

Bytecode is that middle form. It is a simple, regular instruction set that no physical processor executes directly. A separate program called an interpreter reads it and does what it says. Because bytecode is simple and regular, it is unusually easy to reason about, which is exactly why the guarantees are proven there.

Machine code is the final form, the instructions a physical processor runs. Getting from bytecode to machine code means running an optimising compiler, and an optimising compiler is allowed to rewrite the program almost arbitrarily as long as the program still computes the same answers. It may delete work, duplicate work, reorder work and change where values are stored.

The stack frame is the block of memory a function uses for its own working values. How large it is depends on how many values the compiler decides to keep in memory rather than in registers.

Registers are the processor’s small set of very fast storage locations, and there are only a few dozen. Deciding which values live in registers and which get pushed out into the stack frame is a job called register allocation, and it is the compiler’s decision rather than the programmer’s.

That last point is the whole article. The guarantee is a statement about the middle form. The stack frame is a decision the compiler makes about the final form. They are not the same quantity, and nobody had written down an argument connecting them.

The Uncomfortable Answer

Verifying that the compiler is correct is not enough, and this is the part that surprises people who work on verified compilers for a living. A compiler proved correct guarantees that the program still computes the same answers. It says nothing whatever about how much memory or time the program uses, because resource consumption is not part of what “the same answers” means.

So a compiler can be perfectly, provably correct and still multiply a program’s memory use tenfold. Correctness and resource preservation are different properties, and having the first says nothing about the second.

What Was Measured

The system studied here is Keleusma, whose compiler backend is described in the first and second articles in this series. Three results follow, and the one that looks strong is the weak one.

Half the memory bound does not transfer, and the half that fails is not the half that matters most. The proven bound is a sum of two terms. The arena term transfers exactly, because native code allocates from the same fixed-size arena in the same bytes. The operand-slot term counts a structure native code does not have, and the machine frame it was being compared against is a third quantity nobody bounded. The stack frame is decided by the register allocator. Measured across the whole corpus, the compiler emits 38,601 stack allocations with optimisation switched off and exactly zero after the pipeline that actually ships. Promotion removes them, and the unused ones are dead code that the optimiser deletes outright. Whatever the shipped code spends on memory, the proven number is not measuring it, because the two are decided by different agents counting different things.

The time bound is in better shape and its evidence is much weaker than it looks. The argument that a fast implementation is covered by a slow one’s bound is sound in outline, and it rests on an assumption that is testable. This article tests it. The test passes and the sample has only three distinct magnitudes in it, which makes the pass very nearly meaningless.

The third result is that the two bounds fail in different ways, which decides what work each of them needs. One has to be recomputed from the shipped artefact. The other has to be measured.

The Setting

Keleusma refuses any program whose worst-case running time or worst-case memory use cannot be established before it runs. That refusal is the language’s reason to exist, and a program that survives it carries two numbers.

The first is a worst-case time. It is found by looking at every path the program could take through the bytecode, adding up the cost of each instruction along the way, and keeping the most expensive path. The cost of an instruction comes from a table of measured costs, written $c$ below, calibrated against the interpreter that executes bytecode. Formally, with $\Pi(k)$ the set of paths through a unit of code $k$,

The other is a worst-case memory. Bytecode keeps its intermediate values on a stack, and the verifier finds the deepest that stack ever gets. Multiplying that depth by the size of one value, written $w$, and adding a separately computed allocation requirement gives

Both numbers are functions of the bytecode and of nothing else. That is exactly what makes them provable before the program runs, and it is exactly the property this article puts under strain, because the artefact that ships is not the bytecode.

The path from one to the other runs through LLVM, a widely used compiler toolkit. The backend translates bytecode into LLVM’s own intermediate form, and LLVM turns that into machine code for whichever processor is being targeted.

Notation

Let $P$ denote a program and $\mathcal{B}(P)$ its bytecode. Write

for the verifier’s time and memory bounds, and

for the true worst case of the native artefact on its target.

Two symbols carry general meanings and two carry specific ones, which is worth stating once. $\Phi$ is any property whatever and $\mathcal{T}$ any transformation, both introduced in the opening. $\mathcal{R}$ is a resource measure, which is the particular kind of property this article is about, and $\mathcal{C}$ is a compiler, which is the particular kind of transformation. Allocation counts are written out as $\mathrm{allocs}$ rather than abbreviated, so that $A$ always means the artefact a property was established about. The claim under examination is the transfer claim,

for constants $\alpha, \beta$ that do not depend on $P$. Everything turns on whether such constants exist, and the two halves fail differently.

Result 1: One Term of the Memory Bound Transfers Exactly and the Other Describes Nothing Native

The proven memory bound counts slots on the bytecode’s own value stack. Quoting it in bytes means multiplying by the width of one slot, the $w$ above, which on this target is eight,

Across the units of code this article measures, which are the entry points of the language’s stream construct, it ranges from 384 to 2,464 bytes, with between 6 and 71 named variables each.

The bound is a sum of two terms, and only one of them is in trouble

That equation has been printed three times in this series and read as a single number. It is not a single number. It is a sum of two quantities that behave completely differently when the program is compiled, and separating them is the difference between a claim that survives challenge and one that does not.

The $\mathrm{arena}(k)$ term transfers exactly, and nothing in this article disturbs it. The language allocates dynamic data from a fixed-size arena with countable bytes, the memory-bound pass sums the size of every allocation, and native code allocates from the same arena in the same bytes. The flat memory model does not change at the compilation boundary. A bound on arena use proven of the bytecode is a bound on arena use of the machine code, with no argument required beyond noticing that the arena is the same object.

That property is a consequence of the allocation discipline and not a happy accident, which is worth saying because the discipline has a literature and the article’s claim inherits its guarantees. Hanson 1990 gives the practical form, allocating by object lifetime from a region that is released as a unit, and Tofte and Talpin 1997 give the theory that makes region lifetimes statically inferable. Grossman et al. 2002 carry regions into a systems language with the safety obligations discharged, and Berger et al. 2002 measure when a custom allocator actually pays. The relevant property throughout is that a region’s total is decided before the program runs, and it is exactly that property, and not anything about compilation, that lets this term cross the boundary intact.

The $8 \cdot \max_{ip} \mathrm{depth}$ term is the one with no native counterpart. It counts slots on the interpreter’s operand stack, which is a growable vector inside the virtual machine. Native code has no operand stack. Those values live in registers, and where they do not fit they live wherever the register allocator puts them. Comparing that term to a machine frame compares two different things, which is why the comparison came out as badly as it did.

And the machine frame is a third quantity that the bytecode never described at all. It is not the arena term, it is not the operand-slot term, and it needs a bound of its own computed from the artefact.

This is a narrower claim than the one this article set out to make, and a sturdier one. The original framing was that a proven resource bound does not survive compilation. The supportable version is that one component survives exactly, one is an implementation detail of the interpreter with no counterpart on the machine, and a third quantity exists that was never bounded. Every measurement below is unchanged. What changes is which of the three they are about.

The stack frame contains something else entirely, and the way it is built is worth following.

The backend does not consult the proven depth at all. For every function it reserves a fixed 64 slots, whatever the verifier proved, plus one slot for each named variable. In LLVM’s intermediate form each of those reservations is a stack allocation instruction. The rest of the frame is not the backend’s choice either. It is fixed by the target processor’s calling convention, which dictates which registers a function must preserve for its caller and how the frame must be aligned, and those rules come from documents like System V AMD64 and AAPCS64.

So with optimisation switched off the frame is

in which the verifier’s proven depth does not appear anywhere. The number of allocations this predicts is exact rather than approximate, and the measuring instrument asserts it rather than the author eyeballing it,

which matches the measured count across all 19 modules with nothing left over. An equation printed in an article is a claim like any other, so this one is wired to a test that fails if the compiler ever stops behaving that way. A unit of code proven to need three slots and one proven to need sixty are given identical space.

And then the optimiser deletes all of it, in the only place the count can see.

A standard optimisation pass notices that these values never need a memory address and moves every one of them into a register. That is where a careless reading stops, and it would be wrong. The registers the pass moves them into are virtual registers, of which the compiler may invent as many as it likes. A real processor has roughly fourteen it can use freely, so an allocator handed 64 live operand slots pushes most of them straight back onto the stack, which is called spilling.

An earlier version of this article claimed the provisioning is relocated into spill slots rather than removed. That claim was wrong, and it was wrong because the measurement behind it never ran the promotion pass. Promoted then lowered, the 19 modules occupy 5,048 bytes of frame in total, against 275,432 bytes unpromoted, a factor of 54. The provisioning really does leave.

The count going to zero is still a fact about the intermediate representation and not about memory, since what the frame ends up holding is decided afterwards by the register allocator and not by the count.

The frame that actually ships is whatever the register allocator decides it cannot keep in registers. That decision is made by the code generator from the number of registers the target processor has, the exact sequence of optimisation passes, the version of LLVM in use, and the code surrounding the function.

There is no $\beta$. The two quantities are not proportional, not ordered, and not in the same units. $M_{\mathrm{vm}}$ is a property of the program and $M_{\mathrm{nat}}$ is a property of the compiler’s decisions about the program. A bound on the first constrains the second only through an argument nobody has made.

This is the sharpest form of the finding and it is not a defect in the compiler. The translation is doing the ordinary thing that every compiler does. The defect is in the inference, which was never stated explicitly and was therefore never examined.

The frames were measured, and they run the wrong way

The argument above is structural, and a structural argument invites the reply that the numbers might come out fine anyway. They come out differently from the argument, which is worth reporting carefully.

Asking the code generator for an object file carrying a stack-size section, and reading the per-function sizes back out of it, gives the frame each module actually receives. Analysing the artefact rather than a model of it is the established move here, taken by Regehr et al. 2005 on machine code and by Brylow et al. 2001 on interrupt-driven assembly, and the only novelty in this measurement is how cheap the tooling has become. Measured on the code that actually ships, the proven bound exceeds the real frame in every module measured.

Every ratio is below one, and that is the comfortable direction rather than the dangerous one. An artefact provisioned from these proven numbers would be over-provisioned, which wastes memory and keeps its promise.

This does not make the bound sound, and reading it that way would be the same error in the opposite direction. Nothing constructs the agreement. The two quantities are in different units, count different things and are decided by different agents, so eight modules agreeing is a fact about this corpus and not a mechanism. A program with deep expression nesting and few live values could plausibly invert it. The supportable statement is that the bound is empirically conservative on this corpus under the shipped pipeline.

And the ratios do not follow a constant. They range from 0.12 to 0.88 across modules, and three modules sharing a proven bound of 64 receive frames of 56, 40 and 8. A single ratio cannot map one onto the other, so this is not a scaling the project could calibrate once and then rely on.

The same architecture exists in production, and it does not transfer the bound

The closest thing to this system running in production is inside the Linux kernel, and it is worth studying because it faces exactly the same configuration.

Linux lets ordinary programs load small pieces of code into the kernel to filter network packets, trace system behaviour and so on. That is obviously dangerous, so the kernel first verifies the submitted bytecode for termination and resource use, and then compiles it to machine code for speed. A bytecode program is verified, then compiled, and the kernel must not be harmed by the result. The component that does the verifying is called the eBPF verifier.

It does not transfer a memory bound. It fixes one. The stack is capped at a constant, enforced on the bytecode, and the just-in-time compiler is written to respect that cap rather than being trusted to preserve a computed number. The bound is a contract the compiler is built against, not a quantity carried across the boundary.

WebAssembly draws the same line in a different place. Its validation step establishes properties about types and control flow, and deliberately establishes nothing at all about the resource consumption of the compiled result. That omission is a design choice and not an oversight, since Haas et al. 2017 state the format’s goals as hardware independence together with fast validation, and a resource claim would need a target the format refuses to name. Whoever embeds a WebAssembly engine is expected to bound resources by their own means while the program runs.

Neither system does what this project has been assuming. That is the most useful thing the survey contributes, and it points at the two available answers. Either fix a bound that the backend is built to respect, or compute one from the artefact that ships. Transferring a bound across the boundary is not among the options anybody deploys.

Result 2: The Time Bound’s Argument Is Sound And Its Evidence Is Thin

The argument for time is an argument from domination, and in plain terms it is this. If running each operation as machine code is never slower than running it in the interpreter, then whatever bound covers the interpreter also covers the machine code. The slow thing’s limit covers the fast thing.

Written out it needs slightly more. It needs a way of saying which machine instructions came from which bytecode instruction, written $\phi$ below, and it needs each bytecode instruction’s real machine cost to stay inside its modelled cost,

Summing that inequality along the most expensive path gives the conclusion,

with $\pi^{*}$ the worst path. The constant that emerges is the one the transfer claim needed, so $\alpha$ and $\kappa$ are the same number arrived at from two directions, and the article uses $\alpha$ for the claim and $\kappa$ for the per-instruction premise that would establish it.

The premise is an empirical claim and $\phi$ is the fragile part of it. An optimising compiler routinely copies a function’s body into its callers, combines several operations into one wide instruction, deletes work whose result is never used, and shares a computation between two places that both needed it. Every one of those destroys the correspondence $\phi$ presumes. After optimisation there may be no machine instruction attributable to a given bytecode instruction at all, or one machine instruction attributable to a dozen. This is not a difficulty peculiar to this project. Kirner and Puschner 2008 enumerate the obstacles to worst-case timing analysis and name the compiler among them for exactly this reason, and Falk and Lokuciejewski 2010 respond by building a compiler that optimises for worst-case time, which is the constructive form of the same observation.

The argument survives only if the total inequality holds without the correspondence holding, which is a weaker thing to know and a harder thing to establish. It also requires that no operation becomes slower as machine code, which a safety check, a call back into the runtime, or a memory layout unfriendly to the processor’s cache could each violate.

The ordering is testable without any timing equipment. If the bytecode bound is standing in for machine cost, then a unit of code with a larger bound should not produce a smaller body of machine instructions.

Define an inversion as a pair of code units that the two measures order oppositely,

with $S$ the number of machine instructions emitted. A single inversion falsifies the proxy. Only pairs that the bound actually orders can contribute, so the denominator is not the number of pairs but

and a sample concentrated on a few distinct magnitudes drives $N_{\prec}$ far below $\binom{n}{2}$. The inversion count is the numerator of Kendall’s rank correlation, so the result can equivalently be read as

and $\tau = 1$ on a sample of three magnitudes is a much smaller statement than $\tau = 1$ on a spread.

The measurement over every entry point that reaches machine code is as follows.

stream chunks with both figures : 9
comparable pairs                : 36
INVERSIONS                      : 0

Why that zero is much weaker than it appears

Seven of the nine units of code have identical figures, at $T_{\mathrm{vm}} = 14$ and $S = 72$. The sample contains exactly three distinct magnitudes.

The pair counts follow from that table and are worth doing, because they turn the phrase “barely a test” into a number. With $n$ units of code falling into groups of equal bound of sizes $n_{g}$, the pairs the bound strictly orders are the total minus the ties within each group,

The remaining 21 pairs are ties and cannot invert by construction. So the resolution of the test, meaning the fraction of the comparisons the sample is capable of making, is

and those fifteen comparisons are drawn from only three separated size classes. The headline zero is a zero over fifteen comparisons among three values, which is barely a test at all.

Reporting it as “0 of 36” would be the same error this series has now documented three times, being a figure that is arithmetically correct and answers a smaller question than it appears to. The honest statement is that no inversion was found and that the sample lacks the resolution to find one.

Result 3: The Two Bounds Fail Differently, Which Matters For What To Do

The memory bound is broken in kind. No constant relates the two quantities, because one of them is not a property of the program at all. Fixing it means computing a memory bound from the shipped artefact and transferring nothing to it, which is what Regehr et al. 2005 do, and if the result must travel then it travels as evidence attached to the artefact in the manner Necula 1997 describes.

The time bound is unbroken in kind and unevidenced in degree. The domination argument may well hold. It rests on an assumption that has not been tested at any useful resolution, and on a unit conversion $\alpha$ that has never been calibrated. The project’s own architecture notes that the interpreter cost model does not translate and that per-platform calibration is needed, which is the same gap stated from the other side.

Writing $\mathcal{R}$ for a resource measure, and taking the memory case to mean the machine frame against the operand-slot term and not against the arena term, the two gaps differ in kind. Neither is a proven relation and they are unproven for different reasons. The memory case holds on this corpus with $\beta = 1$ and nothing establishes it, since no step of the compilation is required to maintain it. The timing case has an argument behind it and an unmeasured constant,

which call for different work, being an argument in the first case and measurement in the second.

A project that shipped native artefacts today would be shipping part of the language’s central promise unsupported, and would not be lying, because the promise is about the bytecode and the bytecode still carries it. That is precisely the kind of true statement that misleads. The arena half of the promise is genuinely kept. It is the machine stack that has no guarantee behind it, and a reader told only that the memory promise holds would have no way to tell which half was meant.

Threats to Validity

The corpus is small and the part of it this article can measure is smaller. Nine units of code and three widely separated sizes. Every claim about the time proxy is bounded by that.

The instruction count is a proxy for a proxy, and the timing-analysis literature is explicit that a count is not an input it accepts, Wilhelm et al. 2008 setting out the target model any sound analysis needs and Heckmann et al. 2003 showing that the processor decides what is achievable at all. Native instruction count bounds execution time only under a bound on cycles per instruction,

and $\mathrm{CPI}_{\max}$ is exactly what cache misses, branch misprediction and memory stalls make unbounded without a target model. That is the assumption the timing-analysis literature exists to refuse. Instruction count ignores latency, cache behaviour, branch prediction and superscalar issue. A monotone relationship between bound and instruction count is weak evidence for a monotone relationship between bound and time, and no evidence at all about magnitude.

The allocation count is at the intermediate representation, and the frame was measured separately. An earlier version of this article deferred the frame measurement and gave a bad reason for doing so, namely that the per-function frame sizes live in a named section of the object file, in the sense the ELF generic binary interface gives that word and closely related to the metadata LLVM stack maps describe, which the Mach-O development host does not emit. That reasoning confused the host with the target. A compiler cross-targets by construction, so asking llc for an ELF object with a stack-size section and reading it back with llvm-readobj produces the number on any host. The equivalent capability exists in other toolchains as GCC’s -fstack-usage and Clang’s stack-size section.

The measurement is easy to get wrong and this article got it wrong once. The first attempt invoked the back end at two optimisation levels over the same intermediate representation, which never runs the promotion pass at all, so it compared unpromoted code with unpromoted code and read the difference as the effect of optimisation. The corrected measurement promotes first and then lowers, which is what the shipped pipeline does.

No constant factor relates the bound to the frame, which is the sharper point and survives the correction. The ratios run from 0.12 to 0.88, and three modules sharing a proven bound of 64 receive frames of 56, 40 and 8. A single ratio cannot map one onto the other, so the relationship is not a scaling the project could calibrate and then apply. It is the absence of a relationship.

The author wrote both the compiler being measured and the instrument measuring it. The mitigation offered is that the finding is unfavourable to the author’s own prior work and would have been more comfortable suppressed.

Pattern Extraction

Verifying the transformation does not preserve the property. Writing $\mathcal{C}$ for a formally verified compiler, which is one particular transformation $\mathcal{T}$ of the kind this article opened with, what such a compiler proves is semantic equivalence,

while the property wanted here is a separate inequality over a resource measure $\mathcal{R}$,

Neither implies the other. Semantic equivalence quantifies over observable behaviour, and resource use is not observable behaviour in any of these semantics, so a transformation may multiply the stack tenfold and remain perfectly correct. Correctness and resource preservation are independent properties, and a project that has the first frequently believes it has the second.

A property proven of a model constrains the artefact only through a stated argument. The argument here was never written down, which is why it was never checked. Where a claim crosses a representation boundary, the crossing deserves its own explicit statement, and the absence of one is not evidence that it is trivial.

When two measures disagree in kind, no amount of correlation rescues them. The memory bound and the native frame are not weakly correlated. They measure different things, in different units, decided by different agents. Looking for a constant of proportionality between them is a category error dressed as an empirical question.

A zero result inherits the resolution of its sample. Zero inversions over three size classes is not the same claim as zero inversions over a spread, and the two are reported identically by any instrument that prints a count. Report the resolution beside the result or the result will be read as stronger than it is.

The Contemporary Literature

Five literatures bear on whether a resource bound survives translation, and one of them has solved the problem this article discovers. The others each hold a piece. What follows surveys them and marks where the present project sits, which is behind all five.

Resource analysis is a field, and it works on the artefact you intend to run

The static prediction of time and space from program text is mature. Hofmann and Jost 2003 give a type system inferring heap-space bounds for first-order functional programs, and Hoffmann et al. 2012 extend amortised analysis to multivariate bounds. Danielsson 2008 shows the same discipline embedded lightweightly in a dependently typed language.

Directly on the present configuration, Albert et al. 2007a perform cost analysis of Java bytecode, which is exactly the artefact Keleusma’s verifier analyses. That work is careful about what its bounds mean, and it means them about the bytecode, executed by a virtual machine. It does not claim them for a just-in-time compiled result.

The pattern across the field is that the analysis targets the representation that will run. Nobody in this literature proves a bound on one representation and ships another, which is what makes the present project’s assumption unusual rather than merely unverified.

96 contemporary records join the works named above. The field analyses the representation it expects to run, which is the discipline this project did not follow.

• Kanmani and others, 2026, A measurement model for C++ program complexity analysis
• Wani and others, 2026, Constructive realization of self-referential prediction limits in quantum control Resource bounds and Gödel-safe architectures
• Chu and others, 2026, Handling Exceptions and Effects with Automatic Resource Analysis
• Lommen and Giesl, 2026, Modular Automatic Complexity Analysis of Recursive Integer Programs
• Lommen and others, 2026, Targeting Completeness Automated Complexity Analysis of Integer Programs
• van Berkel and others, 2025, A dialectical formalisation of preferred subtheories reasoning under resource bounds
• Nipkow, 2025, Amortized Analysis
• Rustenholz and others, 2025, An Order Theory Framework of Recurrence Equations for Static Cost Analysis Dynamic Inference of Non-Linear Inequality Invariants
• Shehzadi and others, 2025, Automatic Complexity Analysis of UML Class Diagrams Using Visual Question Answering VQA Techniques
• Lian and Wang, 2025, Automatic Linear Resource Bound Analysis for Rust via Prophecy Potentials
• Ghosh and others, 2025, Model of a Static, Spherically Symmetric, Charged Star with Anisotropic Stress and Its Complexity Analysis
• Wang and Ullman, 2025, Resource bounds on mental simulations Evidence from a liquid-reasoning task
• 2025, Supplemental Material for Resource Bounds on Mental Simulations Evidence From a Liquid-Reasoning Task
• Moine and others, 2025, Will It Fit? Verifying Heap Space Bounds of Concurrent Programs under Garbage Collection
• RUSTENHOLZ and others, 2024, A Machine Learning-Based Approach for Solving Recurrence Relations and Its use in Cost Analysis of Logic Programs
• Schoenmakers, 2024, Amortized Analysis of Leftist Heaps
• Grodin and Harper, 2024, Amortized Analysis via Coalgebra
• Ying and Jie, 2024, Automatic Fault Detection Method of Rotating Machinery Bearing Based on Complexity Analysis
• Lommen and others, 2024, Control-Flow Refinement for Complexity Analysis of Probabilistic Programs in KoAT Short Paper
• Hainry and others, 2024, Declassification Policy for Program Complexity Analysis
• Bertholon and others, 2024, Interactive Source-to-Source Optimizations Validated using Static Resource Analysis
• van Brügge, 2024, Liquid Amortization Proving Amortized Complexity with LiquidHaskell Functional Pearl
• Ryu, 2024, Resource Analysis on FPGA for Functional Verification of Digital SRAM PIM
• Pham and others, 2024, Robust Resource Bounds with Static Analysis and Bayesian Inference
• Jin and others, 2024, Sample complexity analysis for adaptive optimization algorithms with stochastic oracles
• Albert and others, 2024, Synthesis of Sound and Precise Storage Cost Bounds via Unsound Resource Analysis and Max-SMT
• Sumitani and others, 2023, A Class of Programs that Admit Exact Complexity Analysis via Newton?s Polynomial Interpolation
• Moine and others, 2023, A High-Level Separation Logic for Heap Space under Garbage Collection
• Grosen and others, 2023, Automatic Amortized Resource Analysis with Regular Recursive Types
• Cimr and others, 2023, Automatic seizure detection by convolutional neural networks with computational complexity analysis
• Dhoked and others, 2023, Constant Amortized Complexity Algorithm
• Westmoreland and Hossain, 2023, Enhancing Cloud Data Processing with Amortized Analysis and Splay Trees for Cyber Threat Intelligence
• Hormann and others, 2023, Range Functions of Any Convergence Order and Their Amortized Complexity Analysis
• Madiot and Pottier, 2022, A separation logic for heap space under garbage collection
• Lommen and others, 2022, Automatic Complexity Analysis of Integer Programs via Triangular Weakly Non-Linear Loops
• Rusch, 2022, Formally Verified Resource Bounds through Implicit Computational Complexity
• Giesl and others, 2022, Improving Automatic Complexity Analysis of Integer Programs
• Disser and Klimm, 2022, The Space Complexity of Undirected Graph Exploration
• Hoffmann and Jost, 2022, Two decades of automatic amortized resource analysis
• Rajani and others, 2021, A unifying type-theory for higher-order amortized cost analysis
• Kahn and Hoffmann, 2021, Automatic amortized resource analysis with the Quantum physicist’s method
• QU and others, 2021, Relational cost analysis in a functional-imperative setting
• Lu and others, 2021, Selectively-Amortized Resource Bounding
• Correas and others, 2021, Static Profiling and Optimization of Ethereum Smart Contracts Using Resource Analysis
• Hu and others, 2021, Synthesis with Asymptotic Resource Bounds
• D’Agostino and Modgil, 2020, A Fully Rational Account of Structured Argumentation Under Resource Bounds
• Cutler and others, 2020, Denotational recurrence extraction for amortized analysis
• Kahn and Hoffmann, 2020, Exponential Automatic Amortized Resource Analysis
• Elsman and Hallenberg, 2020, On the Effects of Integrating Region-Based Memory Management and Generational Garbage Collection in ML
• Bofill and others, 2020, Quantum Zermelo problem for general energy resource bounds
• Curtis and Robinson, 2020, Regional complexity analysis of algorithms for nonconvex smooth optimization
• Moreira and others, 2020, Resource Analysis for Lazy Evaluation with Polynomial Potential
• Sahoo and others, 2020, Space Complexity Analysis in Hybrid Principal Component Analysis
• Çiçek and others, 2020, Static Resource Analysis at Scale Extended Abstract
• Ko, 2020, The amortized analysis of a non-blocking chromatic tree
• Ben-Baruch and others, 2020, Upper and Lower Bounds on the Space Complexity of Detectable Objects
• 2019, 14. Space complexity Modeling limited memory
• Xu and Yap, 2019, Effective Subdivision Algorithm for Isolating Zeros of Real Systems of Equations, with Complexity Analysis
• Zhang and others, 2019, Primal-dual optimization algorithms over Riemannian manifolds an iteration complexity analysis
• Avanzini and others, 2019, Proceedings Third Joint Workshop on Developments in Implicit Computational complExity and Foundational and Practical Aspects of Resource Analysis
• Qu and others, 2019, Relational cost analysis for functional-imperative programs
• Amy, 2019, Sized Types for Low-Level Quantum Metaprogramming
• 2019, Space complexity
• Park and Morrison, 2019, System design and resource analysis for persistent robotic presence with multiple refueling stations
• Avanzini and others, 2019, Type-Based Complexity Analysis of Probabilistic Functional Programs
• Siglmüller, 2019, Type-Based Resource Analysis on Haskell
• Sai Krishna Mohan, 2019, Understanding Time and Space Complexity in Algorithms
• Hainry and Péchoux, 2018, A type-based complexity analysis of Object Oriented programs
• Bahendwar and others, 2018, Amortized Complexity Analysis for Red-Black Trees and Splay Trees
• Nipkow and Brinkop, 2018, Amortized Complexity Verified
• Moser and Schneckenreither, 2018, Automated Amortised Resource Analysis for Term Rewrite Systems
• Ngo and others, 2018, Bounded expectations resource analysis for probabilistic programs
• Schultz, 2018, Reversible Object-Oriented Programming with Region-Based Memory Management
• Bennett and Yap, 2017, Amortized analysis of smooth quadtrees in all dimensions
• Avanzini and Dal Lago, 2017, Automating sized-type inference for complexity analysis
• Shrawankar and Sapkal, 2017, Complexity Analysis of Vedic Mathematics Algorithms for Multicore Environment
• Sinn and others, 2017, Complexity and Resource Bound Analysis of Imperative Programs Using Difference Constraints
• Song and Cai, 2017, Handling of Feature Space Complexity for Texture Analysis in Medical Images
• Kristiansen, 2017, On Resource Analysis of Imperative Programs
• Albert, 2017, Resource Analysis of Distributed and Concurrent Programs
• Hoffmann and others, 2017, Towards automatic resource bound analysis for OCaml
• Danielsson, 2017, Up-to techniques using sized types
• Uno, 2016, Amortized Analysis on Enumeration Algorithms
• Abel, 2016, Compositional Coinduction with Sized Types
• Kirkeby and Rosendahl, 2016, Probabilistic Resource Analysis by Program Transformation
• Rosenbluth, 2016, Resource Analysis of Cognitive Process Flow Used to Achieve Autonomy
• Nugraha and others, 2016, The Use of Life Cycle Cost Analysis to Determine the Most Effective Cost of Installation of 500 kV Java-Sumatra Power Interconnection System
• ABEL and PIENTKA, 2016, Well-founded recursion with copatterns and sized types
• Nguyen and others, 2015, Alternating-time temporal logic with resource bounds
• Nipkow, 2015, Amortized Complexity Verified
• Hofmann, 2015, Automatic amortized analysis
• Niedfeldt and Beard, 2015, Convergence and Complexity Analysis of Recursive-RANSAC A New Multiple Target Tracking Algorithm
• Sinn and others, 2015, Difference constraints an adequate abstraction for complexity analysis of imperative programs
• Nguyen and others, 2015, Speculative region-based memory management for big data systems
• HOFFMANN and SHAO, 2015, Type-based amortized resource analysis with integers and arrays
• Zhang and Tang, 2015, Visual Complexity Analysis of Sparse Imageries for Automatic Laser Scan Planning in Dynamic Environments

Cost-preserving compilation is the exact problem, and it has a research programme

The CerCo project is the closest existing work to what this article says is needed. Amadio and Régis-Gianas 2012 and Ayache et al. 2012 build a certified C compiler that does not transfer a cost bound but lifts a cost model upward, so that the compiler emits cost annotations on the source, justified by the assembly it actually produced, so the bound the programmer reasons about is derived from the artefact and never asserted about a model of it.

That inversion is the whole idea, and it is worth writing the two directions side by side. The move this project had been assuming pushes a bound down onto the artefact, while the move CerCo makes computes it from the artefact and reports it upward,

The compiler is the thing that knows what the code became, so it is the right component to report cost, and a bound computed before compilation is computed by the component with the least information.

Carbonneaux et al. 2014 do the memory half and do it end to end, giving verified stack-space bounds for C programs proven all the way down to the assembly, with the compiler’s own frame decisions inside the proof. Carbonneaux et al. 2015 generalise to compositional certified resource bounds. This is the literature that already contains the answer to Result 1, and its existence means the memory problem here is not open research but unimplemented practice.

Only 4 contemporary records carry this vocabulary at all. That is the smallest cluster in the survey by a wide margin, and the smallness is itself evidence, because the same harvest returned hundreds of records on optimisation and on timing.

• Wu and others, 2025, Cross-Platform Deep Learning Compilation with Model-Specific Cost Model Pre-training
• Shahzad and others, 2024, A Neural Network Based GCC Cost Model for Faster Compiler Tuning
• Mishra and others, 2022, COMPOFF A Compiler Cost model using Machine Learning to predict the Cost of OpenMP Offloading
• Leopoldseder and others, 2018, A cost model for a graph-based intermediate-representation in a dynamic compiler

Worst-case execution time analysis will not accept an operation count

This is the field that predicts how long a program can possibly take on a particular processor, and it is the field a native timing claim would have to satisfy. The standard survey, Wilhelm et al. 2008, sets the requirement plainly. A sound timing analysis needs a model of the target processor’s pipeline and memory hierarchy. Heckmann et al. 2003 make the sharper point that processor architecture determines what any tool can achieve, and Puschner and Burns 2000 give the earlier review of the same ground.

The techniques are specific and not one of them is a count of operations. Li and Malik 1995 turn the search for the most expensive path into an optimisation problem that a solver can answer. Ferdinand and Wilhelm predict cache behaviour precisely enough for such a search to consume. And Reineke et al. 2007 show that the processor’s cache replacement policy itself determines whether prediction is possible at all, so the same program on the same instruction set can be analysable or not depending on a hardware choice nobody in the software made.

Kirner and Puschner 2008 enumerate the obstacles, and the one that matters here is stated plainly in that literature. The compiler is itself an obstacle, because optimisation destroys the correspondence between the structure a person or a verifier reasons about and the sequence of instructions that actually executes. Falk and Lokuciejewski 2010 respond by building a compiler that optimises for worst-case time, which is the constructive version of the same observation.

This is the literature that refuses the second half of the transfer claim. An operation count calibrated against an interpreter is not an input to any of these methods.

This cluster holds 460 contemporary records, more than four times the resource-analysis cluster. The disparity reflects that timing is the bound industry is required to certify while memory is mostly left to convention.

• Chung and Lee, 2026, A Cross-Validated DSPN and Worst-Case Response-Time Framework for Timing Analysis of Automotive CAN Networks
• Li and others, 2026, Balancing Security and Schedulability WCET Evaluation and Security Optimization in CPS
• Fritchey, 2026, Execution Plan Cache Behavior
• Boulifa and others, 2026, Future Result Capture Timing Anomalies Reveal Data from Instructions in the Successor
• Ji and others, 2026, HeteroSTA3D A CPU-GPU Heterogeneous Static Timing Analysis Engine for 3D ICs
• Ishika and others, 2026, Machine Learning-based Cache Replacement Policy for Performance Optimization in Modern Processors
• Vijayalakshmi and Pranaykumar, 2026, Static Timing Analysis of MAC Units Using Approximate Multipliers for Energy-Efficient Computing
• Sahin, 2026, TimeProbe A Measurement-Based Probabilistic Timing Analysis Tool
• Seidler and others, 2026, Wasm-WCET Worst-Case Execution-Time Analysis of WebAssembly Modules on Updatable Resource-Constrained Embedded Devices
• Essabyr and others, 2026, Work in Progress Exploring Timing Anomalies in Multi-Core Systems with Time Petri Nets
• Xu and others, 2026, Xihe A WCET analysis tool for digital signal processors
• Kahlen and Reineke, 2025, A Unified Framework for Quantitative Cache Analysis
• Alzoubi and others, 2025, An efficient low aggressiveness portion ELAP cache replacement policy for systems with non-volatile main memory
• Kaestner and others, 2025, Determining Worst-Case Execution Time Bounds for Multi-Core Processors
• Yu, 2025, DYHR An Efficient Cache Replacement Strategy for Gnn Based on Hybrid Memory
• Berger and others, 2025, Dynamic Fuzzing-Based Whole-System Timing Analysis
• She and others, 2025, Formal Timing Analysis and Verification of the Interrupt-driven Programs for ISO26262
• Shil and others, 2025, Handling Latch Loops in Timing Analysis with Improved Complexity and Divergent Loop Detection
• Lehmann and others, 2025, Hardware/Software Co-Analysis for Worst Case Execution Time Bounds
• Shah and others, 2025, Impact of Hardware Trojan on Cache Replacement Policy
• Liu and others, 2025, IncreGPUSTA GPU-Accelerated Incremental Static Timing Analysis for Iterative Design Flows
• Venkitaraman and others, 2025, LiC Low-Cost Cache Replacement Algorithm for All Cache Levels
• Korkmaz and others, 2025, Locality-Aware Cache Replacement Policy for Graph Traversals
• Magnani and others, 2025, Modern Llvm-Based Compiler Autotuning for Wcet Optimization
• Jiang, 2025, Optimizing WCET Analysis on Timing-Anomaly-Free Architectures
• Mazzucato and others, 2025, Quantitative Static Timing Analysis
• Kumar and Nath, 2025, RECminThrash Recency and Eviction Count Based Cache Replacement Policy to Minimize Thrashing at the Last Level Caches
• Guvvala, 2025, REVOLUTIONIZING STATIC TIMING ANALYSIS THROUGH MACHINE LEARNING INTEGRATION
• 2025, Selected abstracts from the 24th Biennial WCET® Congress in Glasgow, UK
• Guvvala, 2025, STATIC TIMING ANALYSIS STA FUNDAMENTALS AND IMPLEMENTATION IN NANOMETER DIGITAL DESIGN
• Nashipudi and Madhura, 2025, Static Timing Analysis on Retinex RTL Design
• Zhao and others, 2025, Tight Cache Contention Analysis for WCET Estimation on Multicore Systems
• Li and others, 2025, Unified Timing Analysis for Closed-Loop Goal-Oriented Wireless Communication
• Amalou and Puaut, 2025, Using machine learning for timing analysis where do we stand?
• Haesler and others, 2025, WCET®’s International Ostomy Guideline survey of stakeholder priorities
• Bendellaa and Cucu-Grosjean, 2025, Work-in-Progress A WCET Estimation Model of Programs on Real-Time GPUs
• Merazga and others, 2025, Worst-Case Execution Time Analysis of a Real-Time System based on Arduino in CAN Network
• Hu and others, 2024, An Abstract Interpretation-Based Framework for WCET Analysis of Parallel Programs
• Thomas and others, 2024, Analyzing Data Flow and Control Flow of Multicore Software A Solution for Efficient Worst-Case Execution Time Analysis
• Guo and others, 2024, Analyzing Timing in Shorter Time A Journey Through Heterogeneous Parallelism for Static Timing Analysis
• Yi and Dutt, 2024, BoostIID Fault-agnostic Online Detection of WCET Changes in Autonomous Driving
• Xiao and others, 2024, Cache Behavior Analysis with SP-Relative Addressing for WCET Estimation
• Skilkov and Klyatchenko, 2024, Complex methodology for determining WCET in modeling real-time system operation processes
• Crouzet and others, 2024, Coordinating the Fetch and Issue Warp Schedulers to Increase the Timing Predictability of GPUs
• Obulesu and others, 2024, Design and Implementation of Low Power, Area Crosstalk Reduction Using Static Timing Analysis
• Andrade and others, 2024, Drawing Lines for Measurement-Based Probabilistic Timing Analysis
• Teper and others, 2024, End-To-End Timing Analysis and Optimization of Multi-Executor ROS 2 Systems
• Aiswarya and others, 2024, Enhancing Static Timing Analysis Efficiency for RISC-V Processors Through Optimization Techniques
• Guo and Boyer, 2024, From cache and memory management to WCET analysis
• Lin and others, 2024, GCS-Timer GPU-Accelerated Current Source Model Based Static Timing Analysis
• Yang and others, 2024, Implications of architecture and implementation choices on timing analysis of automotive CAN networks
• Palomo and Molina, 2024, ITER an ITERative approach for inter-core timing analysis in statically scheduled cyclic executive systems on COTS multicore platforms for CRTES
• Wang and others, 2024, LSTM-CRP Algorithm-Hardware Co-Design and Implementation of Cache Replacement Policy Using Long Short-Term Memory
• Short, 2024, On Probabilistic Timing Analysis of Fault-Tolerant Real-Time Systems Experiencing Random Errors
• You and Lee, 2024, Overhead Analyses of Cache Replacement Policies and Region Mapping Replacement Policy
• Patel and others, 2024, Performance Analysis of Weighted Victim Cache Replacement Policy
• Zakeri, 2024, Pulsar timing anomalies a window into baryon number violation
• Souza and Freitas, 2024, Reinforcement Learning-Based Cache Replacement Policies for Multicore Processors
• Yang, 2024, Research on Optimization of Adaptive Cache Replacement Algorithm Strategy
• Xu, 2024, Research on WCET assessment method of airborne display software
• 2024, Selected abstracts from the 24th Biennial WCET® Congress in Glasgow, UK
• Roumage and others, 2024, Static Timing Analysis of Cyber-Physical Systems with Relaxed Real-Time Constraints
• S and others, 2024, Static Timing Analysis of Nonlinear-Feedback Shift Register
• Lu and others, 2024, TDC Pool-Level Object Cache Replacement Algorithm Based on Temperature Density
• Nagy, 2024, Timing Analysis
• Burns and Baruah, 2024, Utilising Assumptions to Determine the WCET of Multi-component Classification Systems
• Kumar and others, 2024, Utilizing Machine Learning Techniques for Worst-Case Execution Time Estimation on GPU Architectures
• Moghaddam and Parand, 2024, WCET estimation using support vector regression based on Legendre orthogonal kernel functions
• Samiei and others, 2024, Worst-Case Execution Time Analysis of Real-Time Robotic Algorithms Using Reinforcement Learning
• Yang and others, 2023, A Prefetch-Adaptive Intelligent Cache Replacement Policy Based on Machine Learning
• He and others, 2023, A Survey on Machine Learning-Based Technology for Static Timing Analysis in Agile Design
• Guo and others, 2023, Accelerating Static Timing Analysis Using CPU-GPU Heterogeneous Parallelism
• ONAY and KARAÇALI, 2023, Accelerometer-Based Timing Analysis for Parkinson’s Disease Classification
• Sahu and others, 2023, An augmented cache replacement policy RTC_RRIP for last level cache L3 in state of art multi-core processors
• Hameed and others, 2023, An energy-efficient cache replacement policy for ultra-dense racetrack memory
• Takayama and Tada, 2023, An Implementation of an Instruction Controlled Cache Replacement Policy on a RISC-V Processor
• 2023, AN IN-DEPTH REVIEW ON CACHE REPLACEMENT STRATEGY IN BIGDATA ANALYTICS
• Barbhaya and Mehta, 2023, An Open-Source Static Timing Analysis EDA Tool for Digital System Design
• Paraman and Murthy, 2023, Analysis of benchmark program results of worst case execution time for multithreaded programs
• Yu and others, 2023, Application of Combinatorics Based on Discrete Analysis in WCET Embedded Software Testing Technology
• Raslan and Ismail, 2023, Deep-learning cell-delay modeling for static timing analysis
• Hazra and others, 2023, Design, threat analysis and countermeasures for cache replacement policy-affecting Hardware Trojans in the context of a many-core system
• Sternal, 2023, Diagnostics of Worst-Case Execution Time Calculations for Automotive Embedded Systems
• Tran and Lee, 2023, EFI Cache Replacement Policy Using Eviction Frequency Integration
• Gruin and others, 2023, Enabling timing predictability in the presence of store buffers
• Ye and others, 2023, Graph-Learning-Driven Path-Based Timing Analysis Results Predictor from Graph-Based Timing Analysis
• Sekardefi and Muldina Negara, 2023, Impact of Data Freshness-aware in Cache Replacement Policy for NDN-based IoT Network
• Do and Lin, 2023, Intelligent Thread-Specific Rename Register Allocation for Simultaneous Multi-Threading Processors Based on Cache Behavior
• Touzeau and Reineke, 2023, Leveraging LLVM’s ScalarEvolution for Symbolic Data Cache Analysis
• Li and others, 2023, LOACR A Cache Replacement Method Based on Loop Assist
• Ranjit Kannan and Lakshminarayanan, 2023, Novel Approach for the Reduction of Critical Paths in Static Timing Analysis Without Degradation in QOR
• Qiu and others, 2023, OA-Cache Oracle Approximation-Based Cache Replacement at the Network Edge
• Singh and Srivastava, 2023, Optimisation of cache replacement policy using extreme learning machine
• Cagnizi and others, 2023, Poster Abstract Run-time Dynamic WCET Estimation
• Westermann and others, 2023, Representing Timed Automata and Timing Anomalies of Cyber-Physical Production Systems in Knowledge Graphs
• Yun and Kang, 2023, Runtime WCET Estimation Using Machine Learning
• Lin and others, 2023, Scheduling Periodic Segmented Self-Suspending Tasks without Timing Anomalies
• Shylashree and others, 2023, Soft-Delay Reduction with Greedy Path-Fixing Based Timing Analysis Technique
• Khan and others, 2023, Spherical Fuzzy Rough EDAS Method Under Einstein Aggregation Operators Applications in Cache Replacement Policy
• Khvatov, 2023, Static Timing Analysis Method for Reconfigurable SoC with Various Types of Routing Resources
• Sultana and Alam, 2023, Static Timing Analysis of Different SRAM Controllers
• Yuan and others, 2023, System Static Timing Analysis Method Based on Hierarchization
• Roy, 2023, Timing Analysis
• Sobhani and others, 2023, Timing Analysis and Priority-driven Enhancements of ROS 2 Multi-threaded Executors
• El Yaacoub and others, 2023, Timing Analysis of Embedded Software Updates
• Barone and others, 2023, Timing Behavior Characterization of Critical Real-Time Systems through Hybrid Timing Analysis
• Mubeen, 2023, Timing Predictability and Performance Standoff in Component-based Vehicle Software on Multi-core
• Fraccaroli and others, 2023, Timing Predictability for SOME/IP-based Service-Oriented Automotive In-Vehicle Networks
• Fischer and Falk, 2023, WCET Analysis of Shared Caches in Multi -Core Architectures using Event-Arrival Curves
• Grebant and others, 2023, WCET analysis with procedure arguments as parameters
• Chabal and others, 2023, WCET® 2023 membership survey results reviewing the past and planning the future
• 2023, WCET® Global connectedness common issues and proposed solutions
• He and others, 2023, Workload-Aware Cache Replacement Policy Based on Bayesian Inference
• Rodriguez Ferrandez and others, 2023, Worst Case Execution Time and Power Estimation of Multicore and GPU Software A Pedestrian Detection Use Case
• BAI and others, 2022, 28nm Atom-Switch FPGA Static Timing Analysis and Evaluation
• Victoria Priscilla and Charulatha, 2022, A Deep Dive Comparison of Cache Replacement Strategies The Quality of Experience Influencer
• Jingyu Zhang and others, 2022, A Memory-Aware Spark Cache Replacement Strategy
• Zhou and others, 2022, An End-to-End Automatic Cache Replacement Policy Using Deep Reinforcement Learning
• Seifert, 2022, Analysemethodiken zur Berechnung der WCET mit asynchroner Ein-/Ausgabeverarbeitung
• Jadhav and Falk, 2022, Approximating WCET and Energy Consumption for Fast Multi-Objective Memory Allocation
• Mogaibel, 2022, Attack Resilience of Statistics-based Recently Used Cache Replacement Policy in Software-Defined Networks
• Gu and others, 2022, BLCR Block-Level Cache Replacement for Large-Scale In-Memory Data Processing Systems
• Li and others, 2022, Cache Replacement Algorithm Based on Dynamic Constraints in Microservice Platform
• WanXin and others, 2022, CUDA Acceleration of Worst-Case Execution Time Analysis Based On Model Checking
• Bensaid and others, 2022, Deriving Pipeline Models for Timing Analysis from High-Level HDL Processor Designs
• Cai and others, 2022, Dynamic Cache Replacement Strategy of Space Information Network Based on Cache Value
• Fritchey, 2022, Execution Plan Cache Behavior
• Bekdemir and Bazlamaçcı, 2022, Hybrid probabilistic timing analysis with Extreme Value Theory and Copulas
• Athni and others, 2022, Improved Cache Replacement Policy based on Recency Time Re-Reference Interval Prediction
• Choi and Park, 2022, Learning Future Reference Patterns for Efficient Cache Replacement Decisions
• Kaur and others, 2022, Ml-Powered Cache Replacement Algorithm
• Zhang and others, 2022, Precise and scalable shared cache contention analysis for WCET estimation
• Peng and others, 2022, Pythagorean fuzzy soft decision-making method for cache replacement policy selection in fog computing
• Bettonte and others, 2022, Quantum Approaches for WCET-Related Optimization Problems
• 2022, Selected abstracts from the 23rd Biennial WCET® Congress in Fort Worth, Texas
• Priya Dharishini and Ramana Murthy, 2022, Static Analyzer for Computing WCET of Multithreaded Programs using Hoare’s CSP
• Prabhu and others, 2022, Static Timing Analysis of Multibit Flipflop based LFSR
• Binder and others, 2022, The Role of Causality in a Formal Definition of Timing Anomalies
• Cao and others, 2022, Timing Analysis and Optimization Method with Interdependent Flip-Flop Timing Model for Near-Threshold Design
• Nélis and others, 2022, Timing Analysis Methodology
• Anik and Lee, 2022, Trace Characterization based Cache Replacement Policy
• Yang and others, 2022, Transformer-Based Cache Replacement Policy Learning
• Peng and others, 2022, When CCN meets MCGDM optimal cache replacement policy achieved by PRSRV with Pythagorean fuzzy set pair analysis
• Pasquale and Puaut, 2022, Winston Revisiting iterative compilation for WCET minimization
• Yang and others, 2022, Work-in-Progress ExpCache Online-Learning based Cache Replacement Policy for Non-Volatile Memory
• Susca and others, 2022, Worst-Case Execution Time Estimation for Numerical Controllers
• Chen and others, 2021, A Dynamic Link-latency Aware Cache Replacement Policy DLRP
• Dutta and others, 2021, A Fairness Conscious Cache Replacement Policy for Last Level Cache
• Pham and others, 2021, A Prediction-Based Cache Replacement Policy for Flash Storage
• Wang and others, 2021, An efficient Intelligent Cache Replacement Policy Suitable for PACS
• Schuster and others, 2021, Annotate once analyze anywhere context-aware WCET analysis by user-defined abstractions
• Wang, 2021, Application of Machine Learning Algorithm in Cache Replacement Strategy
• Xie and others, 2021, Attack Resilience of Cache Replacement Policies
• B. and M., 2021, Characterization and hierarchical static timing analysis of mixed-signal design
• Sotin and others, 2021, Data Cache Analysis by Counting Integer Points
• Kumar, 2021, Deep Neural Network Approach to Estimate Early Worst-Case Execution Time
• Sethumurugan and others, 2021, Designing a Cost-Effective Cache Replacement Policy using Machine Learning
• Meng and others, 2021, Establish Program WCET and Energy Consumption Prediction Model Based on L-M Algorithm
• Denzler and others, 2021, Experiences from Adjusting Industrial Software for Worst-Case Execution Time Analysis
• Vu and others, 2021, Experimental Evaluation of Statistical Model Checking Methods for Probabilistic Timing Analysis of Multiprocessor Systems
• Guo and others, 2021, GPU-accelerated Path-based Timing Analysis
• BEKDEMİR and BAZLAMAÇCI, 2021, Hybrid Probabilistic Timing Analysis
• Binder and others, 2021, Is This Still Normal? Putting Definitions of Timing Anomalies to the Test
• Inoue, 2021, Multi-step LRU SIMD-based Cache Replacement for Lower Overhead and Higher Precision
• Balaji and others, 2021, P-OPT Practical Optimal Cache Replacement for Graph Analytics
• Ying Liu and others, 2021, PBRS A Content Popularity and Betweenness Based Cache Replacement Scheme in ICN-IoT
• Chabal and others, 2021, Practice Implications from the WCET® International Ostomy Guideline 2020
• Dharishini and Murthy, 2021, Precise Shared Instruction Cache Analysis to Estimate WCET of Multi-threaded Programs
• Brandner and Noûs, 2021, Precise, efficient, and context-sensitive cache analysis
• Chen and others, 2021, Prefetch and Cache Replacement Based on Thompson Sampling for Satellite IoT Network
• Benz and Bringmann, 2021, Scenario-Aware Program Specialization for Timing Predictability
• Gruin and others, 2021, Speculative Execution and Timing Predictability in an Open Source RISC-V Core
• Taraate, 2021, Static Timing Analysis
• Denzler and others, 2021, Static Timing Analysis of OPC UA PubSub
• Banham and Brown, 2021, The Impact of Über-Authorities on WCET
• Gunzel and others, 2021, Timing Analysis of Asynchronized Distributed Cause-Effect Chains
• Gliwa, 2021, Timing Analysis Techniques
• Li and others, 2021, Towards a Hybrid Probabilistic Timing Analysis
• Costa and others, 2021, Use of Measurements in Worst-Case Execution Time Estimation for Real-Time Systems
• Lübke and Schupp, 2021, WCET-aware reachability for verified simplex design
• Ghose and Kapoor, 2021, WeiSub Weighted Subset-based Cache Replacement Policy for Last Level Caches
• Búr and others, 2021, Worst-case Execution Time Calculation for Query-based Monitors by Witness Generation
• Weiss and others, 2021, Worst-Case Failover Timing Analysis of Distributed Fail-Operational Automotive Applications
• Tada and Higashi, 2020, A Cache Replacement Policy with Considering Fluctuation Patterns of Total Priority Value
• Das and Roy, 2020, A Categorical Study on Cache Replacement Policies for Hierarchical Cache Memory
• Zhang and others, 2020, A Dynamic Instruction Cache Locking Approach for Minimizing Worst Case Execution Time of a Single Task
• Li and others, 2020, A hybrid timing analysis method based on the isolation of software code block
• Mourad and others, 2020, A Novel Approach to Cache Replacement Policy Model Based on Genetic Algorithms
• Huybrechts and others, 2020, A Survey on the Software and Hardware-Based Influences on the Worst-Case Execution Time
• Yoon and Woo Ro, 2020, Access Characteristic-based Cache Replacement Policy in an SSD
• Li and others, 2020, Adaptive priority-based cache replacement and prediction-based cache prefetching in edge computing environment
• Wang and others, 2020, Addressing Resource Contention and Timing Predictability for Multi-Core Architectures with Shared Memory Interconnects
• Nguyen and others, 2020, Advanced On-Chip Variation in Static Timing Analysis for Deep Submicron Regime
• Iyenghar and others, 2020, Automated End-to-End Timing Analysis of AUTOSAR-based Causal Event Chains
• Miura and others, 2020, Cache Replacement Based on LSTM in the Second Cache in Virtualized Environment
• Jiang and Zhang, 2020, Cache Replacement Strategy With Limited Service Capacity in Heterogeneous Networks
• Arima, 2020, Classification-Based Unified Cache Replacement via Partitioned Victim Address History
• Muts and Falk, 2020, Compiler-based WCET prediction performing function specialization
• Li and others, 2020, Component-based Timing Analysis for Embedded Software Components in Cyber-Physical Systems
• Zhang and others, 2020, Delay-Optimal Edge Cache Replacement with Non-Markovian Content Fetching
• Shah and Mehta, 2020, Development of Static Timing Analysis Tool in Perl
• Yamaki, 2020, Effective cache replacement policy for packet processing cache
• Shah and others, 2020, Estimating WCET using prediction models to compute fitness function of a genetic algorithm
• Baig and Madsen, 2020, Genetic Circuits Timing Analysis
• Guo and others, 2020, GPU-accelerated static timing analysis
• Keerthykrishna and others, 2020, Hardware Trojan detection with node reduction using static timing analysis
• Bai and others, 2020, Improving the Performance of WCET Analysis in the Presence of Variable Latencies
• KUZHAN and ŞAHİN, 2020, MBBench A WCET Benchmark Suite
• Jamil and others, 2020, Measurement-Based Timing Analysis on Heterogeneous MPSoCs A Practical Approach
• Fusi and others, 2020, On the Use of Probabilistic Worst-Case Execution Time Estimation for Parallel Applications in High Performance Systems
• Zhang and others, 2020, Predicting Performance Degradation on Adaptive Cache Replacement Policy
• Chabal and others, 2020, Results of the WCET® 2019 Membership Survey Implications and planning
• 2020, Simulator-based Framework towards Improved Cache Predictability for Multi-core Avionic System
• Ueter and others, 2020, Simultaneous Progressing Switching Protocols for Timing Predictable Real-Time Network-on-Chips
• Wang and others, 2020, Static Timing Analysis STA with Timing Bleed Certifying Much Higher Performance for Rapid Single Flux Quantum RSFQ Logic
• Wang and You, 2020, Summary of Tools in FPGA Static Timing Analysis
• Meng and others, 2020, Survey on Estimation and Optimization of Worst-case Execution Time with Energy Consumption Constraint
• Wilhelm and others, 2020, Testing Implementation Soundness of a WCET Analysis Tool
• Swann and others, 2020, Timing anomalies in comb-based optical two-way time-frequency transfer O-TWTFT
• Mubeen and others, 2020, Timing Predictability and Security in Safety-Critical Industrial Cyber-Physical Systems A Position Paper
• Reghenzani and others, 2020, Timing Predictability in High-Performance Computing With Probabilistic Real-Time
• Steurer and others, 2020, Utilizing Model-based Timing Analysis for Holistic Dependability Assessment of Unmanned Aerial Vehicles
• Zhang and others, 2020, WCET Aware Cache Locking and Task Scheduling in Single Core Embedded Systems
• Reder and Becker, 2020, WCET-aware Code Generation and Communication Optimization for Parallelizing Compilers
• Ventovaara and others, 2020, Worst-case Execution Time Estimation of Legacy Vehicular Embedded Functions An Industrial Case Study
• Finzi and Mifdaoui, 2020, Worst-Case Timing Analysis of AFDX Networks With Multiple TSN/BLS Shapers
• Tada and Higashi, 2019, A Cache Replacement Policy with Considering Fluctuation Patterns of Total Priority Value
• Tada, 2019, A Cache Replacement Policy with Considering Global Fluctuations of Priority Values
• Peng and others, 2019, A New Generation of Static Timing Analysis Technology Based on N7+ Process-POCV
• Jain and Lin, 2019, A Taxonomy of Cache Replacement Policies
• Tan and others, 2019, Aging-Aware Timing Analysis
• Ayello, 2019, Around the WCET® world International Collaboration
• Ghosh and others, 2019, Comparative Analysis of Control-transfer Instructions On WCET of Real-Time Systems
• 2019, Component, Cache replacement, Multithreading, LIRS, Weak Determinism
• Zuepke and Kaiser, 2019, Deterministic Futexes Addressing WCET and Bounded Interference Concerns
• Kohler and Ernst, 2019, Improving a Compositional Timing Analysis Framework for Weakly-Hard Real-Time Systems
• Tziouvaras and others, 2019, Instruction-Flow-Based Timing Analysis in Pipelined Processors
• Haddadi and others, 2019, IPKB A New Metric for Evaluating Cache Replacement Policies
• Wang and others, 2019, LR-LRU A PACS-Oriented Intelligent Cache Replacement Policy
• Tabassam and others, 2019, Minimizing the Worst Case Execution Time of Diagnostic Fault Queries in Real Time Systems Using Genetic Algorithm
• Xu and others, 2019, Modeling and Timing Analysis for Microkernel-Based Real-Time Embedded System
• Thorn and others, 2019, Probabilistic Timing Analysis of a Periodic Task on a Microcontroller
• Chen and others, 2019, Probabilistic timing analysis of time-randomised caches with fault detection mechanisms
• Cazorla and others, 2019, Probabilistic Worst-Case Timing Analysis
• Reghenzani and others, 2019, Probabilistic-WCET Reliability
• Schuster and others, 2019, Proving Real-Time Capability of Generic Operating Systems by System-Aware Timing Analysis
• Dardaillon and others, 2019, Reconciling Compiler Optimizations and WCET Estimation Using Iterative Compilation
• Yildiz and others, 2019, Software UART A Use Case for VSCPU Worst-Case Execution Time Analyzer
• Benedicte and others, 2019, Towards limiting the impact of timing anomalies in complex real-time processors
• Búr and Varró, 2019, Towards WCET Estimation of Graph Queries@Run.time
• Becker and others, 2019, WCET Analysis meets Virtual Prototyping
• Damschen and others, 2019, WCET Guarantees for Opportunistic Runtime Reconfiguration
• Su and others, 2019, WCET-aware hyper-block construction for clustered VLIW processors
• Kim and others, 2019, WCET-Aware Stack Frame Management of Embedded Systems Using Scratchpad Memories
• Prentice, 2019, WCET® Journal Embracing multi-lingual exposure to enhance global inclusiveness
• Tada, 2018, A Cache Replacement Policy with Considering Global Fluctuations of Priority Values
• Li and others, 2018, A Cache Replacement Strategy Based on Hierarchical Popularity in NDN
• Lai and Wong, 2018, A highly compressed timing macro-modeling algorithm for hierarchical and incremental timing analysis
• Arcaro and others, 2018, A Reliability Evaluation Method for Probabilistic WCET Estimates Based on the Comparison of Empirical Exceedance Densities
• Ajaykumar and Hingoliwala, 2018, A Survey on Adaptive Wildcard Rule Cache Management with Cache Replacement Algorithms for Software - Defined Networks
• Agrahari, 2018, A Survey on Cache Replacement Policy
• Reder and others, 2018, A WCET-aware parallel programming model for predictability enhanced multi-core architectures
• Akhtar and Lee, 2018, Adaptive Cache Replacement in Efficiently Querying Semantic Big Data
• Bang and others, 2018, An adaptive cache replacement policy based on fine-grain reusability monitor
• El-zoghabi and El shenawy, 2018, An Improved Cache Invalidation Policy in Wireless Environment Cooperate with Cache Replacement Policy Based on Genetic Programming
• Vakil-Ghahani and others, 2018, Cache Replacement Policy Based on Expected Hit Count
• Wu and Zhang, 2018, Cache-Aware SPM Allocation to Reduce Worst-Case Execution Time for Hybrid SPM-Caches
• Reghenzani and others, 2018, chronovise Measurement-Based Probabilistic Timing Analysis framework
• Chung and Halim, 2018, Combining Reused Frequency, Most Recently Used and Program Counter Predictor as Last Level Cache Replacement Policy
• OOKA and others, 2018, Compact CAR Low-Overhead Cache Replacement Policy for an ICN Router
• Hussein and Kareem, 2018, Compression And Analysis Between Classic And Modern Cache Replacement Techniques
• Sudha Rani and Seetha, 2018, Data Mining Approaches for Correlation and Cache Replacement in Wireless Ad Hoc Networks
• Tomlinson and others, 2018, Detection of Automotive CAN Cyber-Attacks by Identifying Packet Timing Anomalies in Time Windows
• Olanrewaju and others, 2018, Efficient cache replacement policy for minimising error rate in L2-STT-MRAM caches
• Bouziane and others, 2018, Energy-Efficient Memory Mappings based on Partial WCET Analysis and Multi-Retention Time STT-RAM
• Huangfu and Zhang, 2018, Estimating the Worst-Case Execution Time of the Shared Data Cache in Integrated CPU-GPU Architectures
• Fritchey, 2018, Execution Plan Cache Behavior
• Yamaki, 2018, Flow Characteristic-Aware Cache Replacement Policy for Packet Processing Cache
• Yamaki, 2018, Flow-Length Aware Cache Replacement Policy for Packet Processing Cache
• Lindner and others, 2018, Hardware-in-the-loop based WCET analysis with KLEE
• Péneau and others, 2018, Improving the Performance of STT-MRAM LLC Through Enhanced Cache Replacement Policy
• Huybrechts and others, 2018, Introduction of Deep Neural Network in Hybrid WCET Analysis
• Koh and Chuah, 2018, On the Randomness Timing Analysis of Timing Side Channel Attack on Key Derivation Functions
• Carminati and others, 2018, On the use of static branch prediction to reduce the worst-case execution time of real-time applications
• Garcia-Espinosa and others, 2018, Post-silicon validation based on synthetic test patterns for early detection of timing anomalies
• Venkanna and others, 2018, PSO based optimization of worst-case execution time for ASIP application
• Wen and Zhang, 2018, Regression Based WCET Analysis For Sampling Based Motion Planning
• Feng, 2018, Research on the Cache Replacement Algorithm of Universal Network based on Cooling Mechanism
• Das, 2018, Role of Cache Replacement Policies in High Performance Computing Systems A Survey
• Becker and others, 2018, Scalable and precise estimation and debugging of the worst-case execution time for analysis-friendly processors a comeback of model checking
• Xing and others, 2018, SMT-Based Timing Analysis and Verification of Real-Time Task
• Gupta and Shanker, 2018, SPMC-PRRP A Predicted Region Based Cache Replacement Policy
• Taraate, 2018, Static Timing Analysis
• Moore and others, 2018, Static timing analysis for ring oscillators
• Venkanna and Rao, 2018, Static Worst-Case Execution Time Optimization using DPSO for ASIP Architecture
• Xing and others, 2018, The Attribute-weight Cache Replacement Algorithm for Encrypted Files
• Banditwattanawong, 2018, The Empirical Discovery of Near-Optimal Offline Cache Replacement Policies for Nonuniform Objects
• Banditwattanawong, 2018, The Optimality and Complexity of Offline Cache Replacement Policies for Nonuniform Objects
• Xu and others, 2018, Timing Analysis for Microkernel-based Real-Time Embedded System
• Hartsell and others, 2018, Timing analysis for UAS application software
• Jiang and Lee, 2018, Timing Macro Modeling for Efficient Hierarchical Timing Analysis
• Kahng and others, 2018, Using Machine Learning to Predict Path-Based Slack from Graph-Based Timing Analysis
• Huangfu and Zhang, 2018, WCET Analysis of GPU L1 Data Caches
• Zhang and others, 2018, WCET-Aware Control Flow Checking With Super-Nodes for Resource-Constrained Embedded Systems
• Giroudot and Mifdaoui, 2018, Work-in-Progress Extending Buffer-Aware Worst-Case Timing Analysis of Wormhole NoCs
• Jha and others, 2018, Worst Case Execution Time Estimation for Control Code of Automation Systems
• Aquino and others, 2018, Worst-Case Execution Time Testing via Evolutionary Symbolic Execution
• Sreedharan and Asokan, 2017, A cache replacement policy based on re-reference count
• Le Nours and Postula, 2017, A Hybrid Simulation Approach for Fast and Accurate Timing Analysis of Multi-Processor Platforms Considering Communication Resources Conflicts
• Shah and others, 2017, A prediction model for measurement-based timing analysis
• Chen and others, 2017, A Tile Data Cache Replacement Policy Based on Hierarchical Relationship and Correlation Degree
• Panić and others, 2017, Adapting TDMA arbitration for measurement-based probabilistic timing analysis
• Chen and Beltrame, 2017, An Adaptive Markov Model for the Timing Analysis of Probabilistic Caches
• Su and others, 2017, An Efficient WCET-Aware Instruction Scheduling and Register Allocation Approach for Clustered VLIW Processors
• Sieh and others, 2017, An End-to-End Toolchain From Automated Cost Modeling to Static WCET and WCEC Analysis
• Dash and Swain, 2017, An exclusive cache replacement policy based on read priority and dynamic sliding
• Fedasyuk and others, 2017, Architecture of a tool for automated testing the worst-case execution time of real-time embedded systems’ firmware
• Wagemann and others, 2017, Benchmark Generation for Timing Analysis
• Slijepcevic and others, 2017, Boosting Guaranteed Performance in Wormhole NoCs with Probabilistic Timing Analysis
• Heo and Kim, 2017, Circuit Timing Analysis and Optimization under Flexible Flip-flop Timing Model
• Carminati and others, 2017, Combining loop unrolling strategies and code predication to reduce the worst-case execution time of real-time software
• Zeng and Peir, 2017, Content-Aware Non-Volatile Cache Replacement
• Jia and others, 2017, Cost aware cache replacement policy in shared last-level cache for hybrid memory based fog computing
• Lin and others, 2017, Coupling-Aware Functional Timing Analysis for Tighter Bounds
• Eichler and others, 2017, Demo Abstract Tooling Support for Benchmarking Timing Analysis
• Agrawal and Fohler, 2017, DRAM-related challenges in task scheduling with timing predictability on COTS multi-cores for safety-critical systems
• Eichler, 2017, Ein Benchmarkgenerator zur Bewertung von WCET-Analysatoren
• Weissbrich and others, 2017, FLINT+ A runtime-configurable emulation-based stochastic timing analysis framework
• Kacou and others, 2017, FPGA static timing analysis enhancement based on real operating conditions
• Zhang and others, 2017, Handling write backs in multi-level cache analysis for WCET estimation
• Sewell and others, 2017, High-assurance timing analysis for a high-assurance real-time operating system
• Hausladen and others, 2017, Integration of Static Worst-Case Execution Time and Stack Usage Analysis for Embedded Systems Software in a Cloud-Based Development Environment
• Anwar and others, 2017, Log-buffer aware cache replacement policy for flash storage devices
• Abella and others, 2017, Measurement-Based Worst-Case Execution Time Estimation Using the Coefficient of Variation
• Nokovic and Sekerinski, 2017, Modelling probabilistic timing analysis
• Santinelli and Guo, 2017, On the Criticality of Probabilistic Worst-Case Execution Time Models
• Santos and others, 2017, On the Timing Analysis at Automotive Real-Time Embedded Systems
• Milutinovic and others, 2017, On uses of extreme value theory fit for industrial-quality WCET analysis
• Silva and others, 2017, On Using GEV or Gumbel Models When Applying EVT for Probabilistic WCET Estimation
• Jimenez Gil and others, 2017, Open Challenges for Probabilistic Measurement-Based Worst-Case Execution Time
• Dai and Burns, 2017, Predicting Worst-Case Execution Time Trends in Long-Lived Real-Time Systems
• Fernandez and others, 2017, Probabilistic timing analysis on time-randomized platforms for the space domain
• Murray and others, 2017, Quantifying error Extending static timing analysis with probabilistic transitions
• Martinez and others, 2017, Quantifying WCET reduction of parallel applications by introducing slack time to limit resource contention
• Mische and others, 2017, Reduced Complexity Many-Core Timing Predictability Due to Message-Passing
• Nagar and Srikant, 2017, Refining Cache Behavior Prediction Using Cache Miss Paths
• Knoop and others, 2017, Replacing conjectures by positive knowledge Inferring proven precise worst-case execution time bounds using symbolic execution
• Lu and others, 2017, Research of timing graph traversal algorithm in static timing analysis based on FPGA
• Santinelli and others, 2017, Revising Measurement-Based Probabilistic Timing Analysis
• Yan and others, 2017, Secure Hierarchy-Aware Cache Replacement Policy SHARP
• Chen and others, 2017, Static probabilistic timing analysis with a permanent fault detection mechanism
• Huangfu and Zhang, 2017, Static WCET Analysis of GPUs with Predictable Warp Scheduling
• Mubeen and others, 2017, Supporting timing analysis of vehicular embedded systems through the refinement of timing constraints
• Nolte and others, 2017, Timing Analysis of CAN-Based Automotive Communication Systems
• Lima and Bate, 2017, Valid Application of EVT in Timing Analysis by Randomising Execution Time Measurements
• Mangean and others, 2017, WCET Analysis by Model Checking for a Processor with Dynamic Branch Prediction
• Huangfu and Zhang, 2017, WCET analysis of the shared data cache in integrated CPU-GPU architectures
• Meng and Su, 2017, WCET optimization strategy based on source code refactoring
• Zheng and others, 2017, WCET-Aware Dynamic I-Cache Locking for a Single Task
• Kim and others, 2017, WCET-Aware Function-Level Dynamic Code Management on Scratchpad Memory
• Sheu and others, 2017, Wildcard-rule caching and cache replacement algorithms in Software-Defined Networking
• Mezzetti and others, 2017, Work-in-Progress Paper An Analysis of the Impact of Dependencies on Probabilistic Timing Analysis and Task Scheduling
• Sivadasan and others, 2017, Workload dependent reliability timing analysis flow
• Kafshdooz and others, 2016, A Compile-Time Optimization Method for WCET Reduction in Real-Time Embedded Systems through Block Formation
• Benedicte and others, 2016, A confidence assessment of WCET estimates for software time randomized caches
• Jacobs and others, 2016, A Framework for the Derivation of WCET Analyses for Multi-core Processors
• Mendler and others, 2016, A Novel WCET Semantics of Synchronous Programs
• Kazemi and Cheng, 2016, A Scratchpad Memory-Based Execution Platform for Functional Reactive Systems and Its Static Timing Analysis
• Lee and others, 2016, A simple proof of optimality for the MIN cache replacement policy
• Law and Bate, 2016, Achieving Appropriate Test Coverage for Reliable Measurement-Based Timing Analysis
• Compagnin and Vardanega, 2016, An automated framework for the timing analysis of applications for an automotive multicore processor
• Varma and others, 2016, An efficient methodology to characterize the TSPC flip flop setup time for static timing analysis
• Su and others, 2016, An Efficient WCET-Aware Hybrid Global Branch Prediction Approach
• Gast and Van Houdt, 2016, Asymptotically Exact TTL-Approximations of the Cache Replacement Algorithms LRU m and h-LRU
• Jain and Lin, 2016, Back to the Future Leveraging Belady’s Algorithm for Improved Cache Replacement
• Sewell and others, 2016, Complete, High-Assurance Determination of Loop Bounds and Infeasible Paths for WCET Analysis
• Kumar and others, 2016, Concurrent multi-mode timing model generation for hierarchical timing analysis
• Maritz and others, 2016, Constraining GW signatures in pulsar timing A multi-frequency timing analysis
• Tanasa and others, 2016, Correlation-Aware Probabilistic Timing Analysis for the Dynamic Segment of FlexRay
• Chen and others, 2016, Effects of online fault detection mechanisms on Probabilistic Timing Analysis
• Puffitsch, 2016, Efficient Worst-Case Execution Time Analysis of Dynamic Branch Prediction
• Hahn and others, 2016, Enabling Compositionality for Multicore Timing Analysis
• Guan, 2016, FIFO Cache Analysis for WCET Estimation
• Kosmidis and others, 2016, Fitting processor architectures for measurement-based probabilistic timing analysis
• Thiele and Ernst, 2016, Formal Worst-Case Timing Analysis of Ethernet TSN’s Burst-Limiting Shaper
• Zhang and others, 2016, L2 speech timing analysis based on L1 timing characteristics
• Geanta and others, 2016, Leverage cache replacement policy in multicore processors
• Ruan and others, 2016, MAC A Novel Systematically Multilevel Cache Replacement Policy for PCM Memory
• Berezovskyi and others, 2016, Measurement-Based Probabilistic Timing Analysis for Graphics Processor Units
• Seo and Kim, 2016, Measuring Method of Worst-case Execution Time by Analyzing Relation between Source Code and Executable Code
• Hamin and Jacobs, 2016, Modular Verification of Termination and Execution Time Bounds Using Separation Logic
• Guan, 2016, MRU Cache Analysis for WCET Estimation
• Gavrilov and others, 2016, Multi-interval static timing analysis accounting logic compatibility
• Mubeen and Nolte, 2016, On Timing Analysis of Component-Based Vehicular Distributed Embedded Systems at Various Abstraction Levels
• Seo and Kim, 2016, Operator-data type pair based execution environments independent worst-case execution time measuring method
• Chu and others, 2016, Precise Cache Timing Analysis via Symbolic Execution
• Cazorla and others, 2016, PROXIMA Improving Measurement-Based Timing Analysis through Randomisation and Probabilistic Analysis
• Park and others, 2016, Resource-aware integration of AUTOSAR-compliant ECUs with an empirical wcet prediction model
• Fang and others, 2016, Schedulability Analysis of Timed Regular Tasks by Under-Approximation on WCET
• Chen and others, 2016, Static probabilistic timing analysis in presence of faults
• Taraate, 2016, Static Timing Analysis
• Sapatnekar, 2016, Statistical Timing Analysis
• Mguidich and others, 2016, Time-Accurate ASM as a Refinement Scheme for Worst-Case Execution Time Estimation in Hard Real-Time Systems
• Heo and Kim, 2016, Timing Analysis and Optimization Based on Flexible Flip-Flop Timing Model
• 2016, TIMING ANALYSIS OF PARALLEL EMBEDDED REAL-TIME SOFTWARE-PRACTICAL EXPERIENCES
• Gorina-Careta and others, 2016, Timing predictability enhances regularity encoding in the human subcortical auditory pathway
• Iyenghar and others, 2016, Translating timing requirements of Embedded Software systems modeled in Simulink to a timing analysis model
• Krafczyk and others, 2016, WCET overapproximation for software in the context of a Cyber-Physical System
• 2016, WORST CASE EXECUTION TIME CALCULATION OF PARALLEL EMBEDDED REAL-TIME SOFTWARE
• Skalistis and Simalatsar, 2016, Worst-Case Execution Time Analysis for Many-Core Architectures with NoC
• Amari and others, 2016, Worst-case timing analysis of AeroRing A Full Duplex Ethernet ring for safety-critical avionics
• Ho and others, 2015, A case study of cache performance in ICN Various combinations of transmission behavior and cache replacement mechanism
• Luo and others, 2015, A Fast and Simple Block-Based Approach for Common Path Pessimism Removal in Static Timing Analysis
• Do and others, 2015, A new cache replacement algorithm for last-level caches by exploiting tag-distance correlation of cache lines
• Feng Ye and others, 2015, A Regional Popularity-Aware Cache replacement algorithm to improve the performance and lifetime of SSD-based disk cache
• Huang and Wong, 2015, Accelerated Path-Based Timing Analysis with MapReduce
• Al-Bataineh and others, 2015, Accelerating worst case execution time analysis of timed automata models with cyclic behaviour
• Li and others, 2015, C3 Cooperative Code Positioning and Cache Locking for WCET Minimization
• Zhang and others, 2015, Cache Replacement Improving Based on User Group Interest Degree
• Kamiyama and others, 2015, Cache replacement policy based on server distance
• Mushtaq and others, 2015, Calculation of worst-case execution time for multicore processors using deterministic execution
• Pyka and others, 2015, Case study Performance and WCET analysis for parallelised avionic applications with ODC 2
• Gomes and Hempstead, 2015, Combative cache efficacy techniques Cache replacement in the context of independent prefetching in last level cache
• Mubeen and others, 2015, End-to-End Timing Analysis of Black-Box Models in Legacy Vehicular Distributed Embedded Systems
• Ziccardi and others, 2015, EPC Extended Path Coverage for Measurement-Based Probabilistic Timing Analysis
• Thiele and others, 2015, Formal timing analysis of CAN-to-Ethernet gateway strategies in automotive networks
• Thiele and others, 2015, Formal worst-case timing analysis of Ethernet TSN’s time-aware and peristaltic shapers
• Agirre and others, 2015, IEC-61508 SIL 3 Compliant Pseudo-Random Number Generators for Probabilistic Timing Analysis
• Mussot and Sotin, 2015, Improving WCET Analysis Precision through Automata Product
• Henia and others, 2015, Integrating Formal Timing Analysis in the Real-Time Software Development Process
• Nelis and others, 2015, Methodologies for the WCET Analysis of Parallel Applications on Many-Core Architectures
• Huang and F. Wong, 2015, On fast timing closure speeding up incremental path-based timing analysis with mapreduce
• Vargas and others, 2015, OpenMP and Timing Predictability A Possible Union?
• Kelter and Marwedel, 2015, Parallelism Analysis Precise WCET Values for Complex Multi-Core Systems
• Nagar and Srikant, 2015, Path Sensitive Cache Analysis Using Cache Miss Paths
• Puffitsch, 2015, Persistence-based branch misprediction bounds for WCET analysis
• Zhang and Koutsoukos, 2015, Precise Multi-level Inclusive Cache Analysis for WCET Estimation
• Kim and others, 2015, Resource-Parameterized Timing Analysis of Real-Time Systems
• Jean and others, 2015, Safety considerations for WCET evaluation methods in avionic equipment
• Luppold and Falk, 2015, Schedulability Aware WCET-Optimization of Periodic Preemptive Hard Real-Time Multitasking Systems
• Černý and others, 2015, Segment Abstraction for Worst-Case Execution Time Analysis
• Milutinovic and others, 2015, Speeding up Static Probabilistic Timing Analysis
• Lesage and others, 2015, Static Probabilistic Timing Analysis for Multi-path Programs
• Altmeyer and others, 2015, Static probabilistic timing analysis for real-time systems using random replacement caches
• Reineke and Wilhelm, 2015, Static Timing Analysis What is Special?
• Luckow and others, 2015, Symbolic execution and timed automata model checking for timing analysis of Java real-time systems
• Raymond and others, 2015, Timing analysis enhancement for synchronous program
• Becker and others, 2015, Timing Analysis of Safety-Critical Automotive Software The AUTOSAFE Tool Flow
• Zhang and Koutsoukos, 2015, Top-down and bottom-up multi-level cache analysis for WCET estimation
• Uppal and Meswani, 2015, Towards Workload-Aware Page Cache Replacement Policies for Hybrid Memories
• Li and others, 2015, Tracing Flow Information for Tighter WCET Estimation Application to Vectorization
• Silva and others, 2015, Value analysis for the determination of memory instruction latency in a WCET tool
• Jacobs and others, 2015, WCET analysis for multi-core processors with shared buses and event-driven bus arbitration
• Rihani and others, 2015, WCET analysis in shared resources real-time systems with TDMA buses
• Abella and others, 2015, WCET analysis methods Pitfalls and challenges on their trustworthiness
• Elloumi and others, 2015, WCET nested-loop minimization in terms of instruction-level-parallelism
• Mancuso and others, 2015, WCET m Estimation in Multi-core Systems Using Single Core Equivalence
• Zheng and Wu, 2015, WCET-Aware Dynamic D-cache Locking for A Single Task
• Zhi-Hua and Zhi-Min, 2015, WCET-Aware Task Assignment and Cache Partitioning for WCRT Minimization on Multi-core Systems
• Bai and others, 2015, Window-LRFU a cache replacement policy subsumes the LRU and window-LFU policies

Translation validation is the technique for a compiler you cannot change

The idea is to stop trying to prove the compiler correct once and for all, and instead check each individual run. Pnueli et al. 1998 introduce it and Necula 2000b applies it to an optimising compiler. Rather than proving the compiler correct, prove that this particular output is equivalent to this particular input. Sewell et al. 2013 carry it to a production operating-system kernel by proving the binary refines the C.

That fits the present problem well, because the property here is per-artefact and fragile. A resource bound depends on decisions an optimiser makes for reasons specific to one program, which is precisely the situation translation validation was invented for, and it is much cheaper than verifying an entire backend.

A further 410 contemporary records develop the technique. It checks one compilation and not one compiler, which is why it needs no cooperation from LLVM and why it would have to run on every build.

• Alamoudi, 2026, A bijective proof of Andrews’ refinement of the Alladi-Schur theorem
• Lin and others, 2026, A Mathematical Exploration to Equivalence Checking of Quantum Circuits
• Zhang and others, 2026, A Multi-Level Dataflow Parallel Acceleration Framework for EPS-Based Equivalence Checking
• Del Castillo, 2026, A Symbolic Execution Approach to Bounded Verification of Abstract State Machines
• Iavich and others, 2026, A Symmetry-Theoretic Framework for AI-Guided Symbolic Execution in Embedded Systems
• Burgholzer and Wille, 2026, Advanced Equivalence Checking for Quantum Circuits
• Akdar, 2026, Cell-Based Binary Target Detection and Position Refinement in Multistatic Radar Networks
• Kuehlmann and others, 2026, Equivalence Checking
• Burgholzer and Wille, 2026, Equivalence Checking of Parameterized Quantum Circuits Verifying the Compilation ofVariational Quantum Algorithms
• Dramko and others, 2026, Fast, Fine-Grained Equivalence Checking for Neural Decompilers
• Zhang and others, 2026, FastLEC Parallel Datapath Equivalence Checking with Hybrid Engines
• Lindner and others, 2026, Forward Symbolic Execution for Trustworthy Automation of Binary Code Verification
• Zhang and others, 2026, GPU-accelerated combinational equivalence checking via dataflow-driven parallelism and LRU-aware memory optimization
• Burgholzer and Wille, 2026, Handling Non-unitaries in Quantum Circuit Equivalence Checking
• Oza and others, 2026, LLMs are Brittle to Simple Code Transformations Introducing CETBench A Benchmark for Code-Equivalence Checking
• van Leenen and Kappé, 2026, Octopus Practical Equivalence Checking of P4 Packet Parsers
• Braione and others, 2026, Path-Optimal Symbolic Execution of Heap-Manipulating Programs
• Sarkar and others, 2026, PLCEQ Behavioural Equivalence Checking for Industrial PLC Software Migration
• Liu and Young, 2026, Simulation-based Combinational Equivalence Checking with Multiple GPUs
• Ayoun and others, 2026, Soteria Efficient Symbolic Execution as a Functional Library Perhaps You Should Write Your Own Symbolic Execution Engine!
• Bhabal and others, 2026, Subtitle Translation and Back Translation Validation Using Neural Machine Translation
• Movsisyan and others, 2026, Symbolic Execution for Control Flow Path Feasibility
• Kim, 2025, A Formal Verification Library Design for Behavioral Refinement of CompCert Clight
• Graf and others, 2025, Accelerating Recertification of FPGA-Based Avionics Systems via Bitstream Equivalence Checking
• Tempel and others, 2025, Accurate and Extensible Symbolic Execution of Binary Code Based on Formal ISA Semantics
• Cao and others, 2025, Advancing Code Obfuscation Novel Opaque Predicate Techniques to Counter Dynamic Symbolic Execution
• Zhibo and others, 2025, An Algebraic Approach to the Equivalence Checking of Deterministic Top-down Tree Transducers
• Wilson and Asplund, 2025, Analysing TLS Implementations Using Full-Message Symbolic Execution
• Wei and others, 2025, Auto-CEC Combinational Equivalence Checking via Intelligent Sweeping Engine Selection
• Vouvoutsis and others, 2025, Beyond the sandbox Leveraging symbolic execution for evasive malware classification
• Ankireddy and others, 2025, CLIP A Structural Approach to Cut Points Matching for Logic Equivalence Checking
• Tang, 2025, Combinational Equivalence Checking on AIGs
• Voogd and others, 2025, Compositional symbolic execution semantics
• Chen and others, 2025, Datapath Combinational Equivalence Checking With Hybrid Sweeping Engines and Parallelization
• Yao and She, 2025, Empc Effective Path Prioritization for Symbolic Execution with Path Cover
• Wei and others, 2025, EquiBench Benchmarking Large Language Models’ Reasoning about Program Semantics via Equivalence Checking
• Sander and others, 2025, Equivalence checking of quantum circuits via intermediary matrix product operator
• Pointner and others, 2025, Generating Inputs for Grammar Mining using Dynamic Symbolic Execution
• Sakharova and others, 2025, Integrating Symbolic Execution into the Fine-Tuning of Code-Generating LLMs
• Li and Stratman, 2025, Invited The Future of Functional ECO Automation and Logical Equivalence Checking for Advanced Digital Design Flows
• Ogawa, 2025, Malware Analysis A Perspective from Dynamic Symbolic Execution of Binary Code
• Zakharov and Deng, 2025, On the Equivalence Checking Problem for Deterministic Top-Down Automata
• Kwon and others, 2025, Optimization-Directed Compiler Fuzzing for Continuous Translation Validation
• Zhou and others, 2025, Parallel Dynamic Partitioning for Datapath Combinational Equivalence Checking
• Menshutin, 2025, Path-Minimal Objects in ArkTS Symbolic Execution From Path Constraints to TypeScript Tests
• Movsisyan and others, 2025, Program Path Feasibility Through Symbolic Execution
• Lundberg and others, 2025, Proof-Producing Symbolic Execution for P4
• Sun and Su, 2025, Prove It to the Kernel Precise Extension Analysis via Proof-Guided Abstraction Refinement
• Sohanghpurwala and others, 2025, PV-Bit Private Verification of FPGA Bitstreams Via Bitstream Equivalence Checking
• Dharmathilaka and others, 2025, Refinement of stellar parameters for the eclipsing binary system KIC 8569819 using stellar modeling approach
• Yu and others, 2025, Scalable Equivalence Checking and Verification of Shallow Quantum Circuits
• Cheng and Zhang, 2025, Sequential Equivalence Checking for Specialized IR via Instrumentation-Based Symbolic Execution
• Rizzi and others, 2025, SimGen Simulation Pattern Generation for Efficient Equivalence Checking
• Liu and Young, 2025, Simulation-based Parallel Sweeping A New Perspective on Combinational Equivalence Checking
• Correnson and others, 2025, Symbolic execution for refuting ∀∃ hyperproperties
• Zhang and others, 2025, Unifying Compositional Verification and Certified Compilation with a Three-Dimensional Refinement Algebra
• Jha and others, 2024, cecApprox Enabling Automated Combinational Equivalence Checking for Approximate Circuits
• Thalaimalai Vanaraj and Razdan, 2024, A Case Study on Formal Sequential Equivalence Checking based Hierarchical Flow Setup towards Faster Convergence of Complex SOC Designs
• Troost and others, 2024, An Integrated Visualization Approach Combining Dynamic Data-Flow Analysis with Symbolic Execution
• Aslanyan and others, 2024, Combining Static Analysis With Directed Symbolic Execution for Scalable and Accurate Memory Leak Detection
• Jana and others, 2024, CoTran An LLM-Based Code Translator Using Reinforcement Learning with Feedback from Compiler and Symbolic Execution
• Dai and Yavuz, 2024, Detecting Hardware Trojans using Model Guided Symbolic Execution
• Coşkun and others, 2024, Efficient Equivalence Checking of Nonlinear Analog Circuits using Gradient Ascent
• Wang and Xie, 2024, Enhancing Translation Validation of Compiler Transformations with Large Language Models
• Do and Ogata, 2024, Equivalence Checking of Quantum Circuits Based on Dirac Notation in Maude
• Mei and others, 2024, Equivalence Checking of Quantum Circuits by Model Counting
• Timo and others, 2024, Evaluating trustworthiness of decision tree learning algorithms based on equivalence checking
• Baek and Lee, 2024, Extracting Invariants from Conditional Branches for Abstract Value Refinement in Static Analysis Targeting LLVM IR
• Dxo and others, 2024, Hevm, a Fast Symbolic Execution Framework for EVM Bytecode
• Hedrich and others, 2024, Identifying Undetectable Defects Using Equivalence Checking
• Seres and others, 2024, Is This Really a Refactoring? Automated Equivalence Checking for Erlang Projects
• Bi and others, 2024, Iterative Refinement of Project-Level Code Context for Precise Code Generation with Compiler Feedback
• Nie and Wang, 2024, Parallel Symbolic Execution for Smart Contracts with Load Balancing
• Milovančević and others, 2024, Proving Termination via Measure Transfer in Equivalence Checking
• Lu and others, 2024, QuaSi A Scalable and Reliable Quantum Simulation-based Equivalence Checking Framework
• Zhao and others, 2024, Static Code Analysis of IEC 61131-3 ST Programs via Symbolic Execution
• Pitigalaarachchi, 2024, Symbolic Execution for Dynamic Kernel Analysis
• Glockenmeier and others, 2024, Symbolic Execution-Based Code Coverage Framework for Augmented Software Testing
• Fülöp and Pataki, 2024, Temporal Logic-driven Symbolic Execution with the Clang Static Analyzer
• Quetschlich and others, 2024, Towards Equivalence Checking of Classical Circuits Using Quantum Computing
• Kwon and others, 2024, Translation Validation for JIT Compiler in the V8 JavaScript Engine
• 2024, Triadic Synergy Leveraging Formal Methods, Symbolic Execution, and Machine Learning for Advanced Halting Analysis
• Galustov and Borodin, 2024, User Defined Checkers for Static Analysis with Symbolic Execution
• Zhang and others, 2024, When Compiler Optimizations Meet Symbolic Execution An Empirical Study
• Qian and others, 2023, A measurable refinement method of design and verification for micro-kernel operating systems in communication network
• Hu and Chu, 2023, An efficient circuit-based SAT solver and its application in logic equivalence checking
• Wang and others, 2023, An Equivalence Checking Framework for Agile Hardware Design
• Takemoto and Takada, 2023, Applying Symbolic Execution to Semantic Code Clone Detection S
• Deb and others, 2023, Automated Equivalence Checking Method for Majority Based In-Memory Computing on ReRAM Crossbars
• Safdarian and others, 2023, Automatic Vulnerability Detection in Tizen Applications with Dynamic Symbolic Execution
• Kurian and others, 2023, Automatically generating test cases for safety-critical software via symbolic execution
• Wang and others, 2023, Code-Level Functional Equivalence Checking of Annotative Software Product Lines
• Voogd and others, 2023, Denotational Semantics for Symbolic Execution
• Peham and others, 2023, Equivalence Checking of Parameterized Quantum Circuits
• Coşkun and others, 2023, Equivalence Checking of System-Level and SPICE-Level Models of Static Nonlinear Circuits
• Sugawara and others, 2023, Equivalence Checking of Code Transformation by Numerical and Symbolic Approaches
• Thanos and others, 2023, Fast Equivalence Checking of Quantum Circuits of Clifford Gates
• Cabrero-Holgueras and Pastrana, 2023, HEFactory A symbolic execution compiler for privacy-preserving Deep Learning with Homomorphic Encryption
• Chen and others, 2023, Integrating Exact Simulation into Sweeping for Datapath Combinational Equivalence Checking
• Bandukara and Tzevelekos, 2023, On-the-fly bisimulation equivalence checking for fresh-register automata
• Arusoaie and Lucanu, 2023, Proof-carrying parameters in certified symbolic execution
• Nan and others, 2023, Quantum symbolic execution
• Paduraru and others, 2023, RPA Testing Using Symbolic Execution
• Li and others, 2023, SE3 Sequential Equivalence Checking for Non-Cycle-Accurate Design Transformations †
• Tiraboschi and others, 2023, Sound Symbolic Execution via Abstract Interpretation and Its Application to Security
• Kondratiev and others, 2023, Speeding up the Solving of Logical Equivalence Checking Problems with Disjunctive Diagrams
• Hussein and others, 2023, Structural Test Input Generation for 3-Address Code Coverage Using Path-Merged Symbolic Execution
• Muylaert and others, 2023, Symbolic Execution to Detect Semantic Merge Conflicts
• Huang, 2023, Targeted Symbolic Execution for UAF Vulnerabilities
• Panigrahi and Karfa, 2023, Translation Validation of Information Leakage of Compiler Optimizations
• Zielasko and others, 2022, 3D Visualization of Symbolic Execution Traces
• Hu and others, 2022, A Hybrid Method for Equivalence Checking Between System Level and RTL
• Roy and Chaki, 2022, Achieving high coverage in hardware equivalence checking via concolic verification
• Kurhe and others, 2022, Automatic Generation of Debug Headers through BlackBox Equivalence Checking
• Rutledge and Orso, 2022, Automating Differential Testing with Overapproximate Symbolic Execution
• Singireddy and others, 2022, Deep Learning Toolkit-Driven Equivalence Checking of Flow-Based Computing Systems
• Abderehman and others, 2022, DEEQ Data-driven End-to-End EQuivalence Checking of High-level Synthesis
• Lancia, 2022, Detecting fault injection vulnerabilities in binaries with symbolic execution
• Yogananda Jeppu and others, 2022, Enhancing active model learning with equivalence checking using simulation relations
• Garavel and Lang, 2022, Equivalence Checking 40 Years After A Review of Bisimulation Tools
• Thijssen and others, 2022, Equivalence Checking for Flow-Based Computing
• Hong and others, 2022, Equivalence Checking of Dynamic Quantum Circuits
• Singh, 2022, Equivalence Checking of Non-Binary Combinational Netlists
• Sun and Wei, 2022, Equivalence checking of quantum circuits by nonlocality
• Wang and others, 2022, Equivalence Checking of Sequential Quantum Circuits
• Coskun and others, 2022, Equivalence Checking of System-Level and SPICE-Level Models of Linear Analog Filters
• Coşkun and others, 2022, Equivalence Checking of System-Level and SPICE-Level Models of Linear Circuits
• Peham and others, 2022, Equivalence checking paradigms in quantum circuit design
• Vishnyakov and others, 2022, Error detection in binary code with dynamic symbolic execution
• Yi and Yang, 2022, Feedback-Driven Incremental Symbolic Execution
• Mercaldo and Santone, 2022, Formal Equivalence Checking for Mobile Malware Detection and Family Classification
• Russinoff and others, 2022, Formal Verification of a Chained Multiply-Add Design Combining Theorem Proving and Equivalence Checking
• Dupont and others, 2022, Formally verified architectural patterns of hybrid systems using proof and refinement with Event-B
• Rajput and Gopinath, 2022, GARUDA Heap aware symbolic execution
• Shitrit and Pai, 2022, Generating Test Suites for GPU Instruction Sets through Mutation and Equivalence Checking
• Borzacchiello and others, 2022, Handling Memory-Intensive Operations in Symbolic Execution
• Burgholzer and Wille, 2022, Handling non-unitaries in quantum circuit equivalence checking
• Stolte and Tsvetkov, 2022, Historical Review and Proof-of-Concept Future Method Demonstration of Adaptive Mesh Refinement in Nuclear Engineering for Increased Fidelity and Computational Efficiency
• Bertrand Van Ouytsel and Legay, 2022, Malware Analysis with Symbolic Execution and Graph Kernel
• Eleftheriadis and others, 2022, On Neural Network Equivalence Checking Using SMT Solvers
• Chen and others, 2022, Partial Equivalence Checking of Quantum Circuits
• Arusoaie and Lucanu, 2022, Proof-Carrying Parameters in Certified Symbolic Execution The Case Study of Antiunification
• Sun and Wei, 2022, Publisher Correction Equivalence checking of quantum circuits by nonlocality
• Borzacchiello and others, 2022, SENinja A symbolic execution plugin for Binary Ninja
• Bang and others, 2022, SMT-Based Translation Validation for Machine Learning Compiler
• Parygina and others, 2022, Strong Optimistic Solving for Dynamic Symbolic Execution
• Lungu and Lucanu, 2022, Supporting Algorithm Analysis with Symbolic Execution in Alk
• Steinhöfel, 2022, Symbolic Execution Foundations, Techniques, Applications, and Future Perspectives
• Wang and Fujita, 2022, Template-Based Semi-Formal Approach to Robust Equivalence Checking
• Trabish and others, 2021, A bounded symbolic-size model for symbolic execution
• Burgholzer and Wille, 2021, Advanced Equivalence Checking for Quantum Circuits
• Hong and others, 2021, Approximate Equivalence Checking of Noisy Quantum Circuits
• Chalupa and Strejček, 2021, Backward Symbolic Execution with Loop Folding
• Qin and Han, 2021, BinSEAL Linux Binary Obfuscation Against Symbolic Execution
• Vindum and Birkedal, 2021, Contextual refinement of the Michael-Scott queue proof pearl
• Marinaro and others, 2021, Detecting Call Indirection Obfuscation through Equivalence Checking in Android environment
• Zakharov, 2021, Efficient Equivalence Checking Technique for Some Classes of Finite-State Machines
• Bresolin and others, 2021, Equivalence checking and intersection of deterministic timed finite state machines
• Fu and others, 2021, Equivalence Checking for Superconducting RSFQ Logic Circuits
• Kappé and others, 2021, Equivalence checking for weak bi-Kleene algebra
• Wang and others, 2021, Equivalence checking of quantum finite-state machines
• 2021, Keynote Talk - Fuzzing, Symbolic Execution, and Synthesis for Testing
• Wei and others, 2021, LLSC a parallel symbolic execution compiler for LLVM IR
• Bu and others, 2021, Machine learning steered symbolic execution framework for complex software code
• Han and others, 2021, Parallelizing Compiler Translation Validation Using Happens-Before and Task-Set
• Jakobs, 2021, PatEC Pattern-Based Equivalence Checking
• Speer and Nurminen, 2021, Program Equivalence Checking for the Facilitation of Quantum Offloading
• Burgholzer and Wille, 2021, QCEC A JKQ tool for quantum circuit equivalence checking
• Ye and Lu, 2021, SPOT Testing Stream Processing Programs with Symbolic Execution and Stream Synthesizing
• Lee and Choi, 2021, Static Equivalence Checking for OpenFlow Networks
• Poeplau and Francillon, 2021, SymQEMU Compilation-based symbolic execution for binaries
• Shen, 2021, The Impact of Compiler Optimizations on Symbolic Execution
• Mittal and others, 2021, Towards an Approach for Translation Validation of Thread-level Parallelizing Transformations using Colored Petri Nets
• Kuts, 2021, Towards Symbolic Pointers Reasoning in Dynamic Symbolic Execution
• Ozkan, 2021, Verifying Weakly Consistent Transactional Programs Using Symbolic Execution
• Fülöp and Pataki, 2020, A DSL for Resource Checking Using Finite State Automaton-Driven Symbolic Execution
• Zhang and others, 2020, A Survey of Symbolic Execution and Its Tool KLEE
• Li and others, 2020, Application specified soft-error failure rate analysis using sequential equivalence checking techniques
• Badihi and others, 2020, ARDiff scaling program equivalence checking via iterative abstraction and refinement of common code
• Xie and others, 2020, CSEFuzz Fuzz Testing Based on Symbolic Execution
• Zakharov, 2020, Efficient Equivalence Checking Technique for Some Classes of Finite-State Machines
• Dupont and others, 2020, Embedding Approximation in Event-B Safe Hybrid System Design Using Proof and Refinement
• Tarraf and others, 2020, Equivalence Checking Methods for Analog Circuits Using Continuous Reachable Sets
• Ishikawa and others, 2020, Explicit Exploration of Refinement Design in Proof-Based Approach Refinement Engineering in Event-B
• Brunner, 2020, Formal Verification of Executable Complementation and Equivalence Checking for Büchi Automata
• Bezza and others, 2020, Formalization and Refinement Proof for Embedded Systems
• Dupont and others, 2020, Formally Verified Architecture Patterns of Hybrid Systems Using Proof and Refinement with Event-B
• Srivastava and Chaudhari, 2020, Grain refinement in ultrasonicated binary aluminium alloys
• Husák and others, 2020, Handling Heap Data Structures in Backward Symbolic Execution
• Hsu and others, 2020, ICCAD-2020 CAD contest in X-value equivalence checking and benchmark suite
• Sprenger and others, 2020, Igloo soundly linking compositional refinement and separation logic for distributed system verification
• Burgholzer and Wille, 2020, Improved DD-based Equivalence Checking of Quantum Circuits
• Song and others, 2020, Infeasible Path Detection Based on Code Pattern and Backward Symbolic Execution
• Mues and Howar, 2020, JDart Dynamic Symbolic Execution for Java Bytecode Competition Contribution
• Hong and others, 2020, Modified condition/decision coverage MC/DC oriented compiler optimization for symbolic execution
• Singh and Khurshid, 2020, Parallel Chopped Symbolic Execution
• Possani and others, 2020, Parallel Combinational Equivalence Checking
• Wu and others, 2020, Reinforcement Learning Guided Symbolic Execution
• Feng and others, 2020, Scaling client-specific equivalence checking via impact boundary search
• Namani and Khan, 2020, Symbolic execution based feature extraction for detection of malware
• Pasareanu, 2020, Symbolic Execution The Basics
• Burgholzer and Wille, 2020, The Power of Simulation for Equivalence Checking in Quantum Computing
• Naug, 2020, Useless Code Identification with Symbolic Execution
• Nguyen and Nguyen, 2020, Using Symbolic Execution to Analyze Linux KBuild Makefiles
• Ayari and others, 2019, A Grammar Based Approach to BPMN Model Semantic Preservation using Refinement
• Yang and others, 2019, Advances in Symbolic Execution
• Lim and Nagarakatte, 2019, Automatic Equivalence Checking for Assembly Implementations of Cryptography Libraries
• Amin and Kaprawi, 2019, Content Learning Indicator in Equivalence Checking between Skills Module and Academic Module for APEL Process
• Kovács and others, 2019, Detecting C++ Lifetime Errors with Symbolic Execution
• Ghiduk and others, 2019, Employing Dynamic Symbolic Execution for Equivalent Mutant Detection
• Pham and others, 2019, Enhancing Symbolic Execution of Heap-Based Programs with Separation Logic for Test Input Generation
• Devadoss and others, 2019, Equivalence Checking and Compaction of n-input Majority Terms Using Implicants of Majority
• Zakharov, 2019, Equivalence Checking of Prefix-Free Transducers and Deterministic Two-Tape Automata
• Hu and others, 2019, Equivalence Checking of Scheduling in High-Level Synthesis Using Deep State Sequences
• Nowack, 2019, Fine-Grain Memory Object Representation in Symbolic Execution
• Hu and others, 2019, Formal Equivalence Checking Between System-Level and RTL Descriptions without Pre-Given Mapping Information
• Park and Noh, 2019, Guided Symbolic Execution in Real-World Binary Program
• Dupont and others, 2019, Handling Refinement of Continuous Behaviors A Proof Based Approach with Event-B
• Roy and others, 2019, High Coverage Concolic Equivalence Checking
• Lee and others, 2019, Lightweight Equivalence Checking of Code Transformation for Code Pointer Integrity
• Stankaitis and others, 2019, Modelling Hybrid Train Speed Controller using Proof and Refinement
• Shiqi and others, 2019, Neuro-Symbolic Execution Augmenting Symbolic Execution with Neural Constraints
• de Boer and Bonsangue, 2019, On the Nature of Symbolic Execution
• Wen and Yang, 2019, Parallel property checking with staged symbolic execution
• MOHD AMIN, 2019, PILOT STUDY INDICATOR IN EQUIVALENCE CHECKING FOR APEL
• Horváth and Pataki, 2019, Predicting bugs using symbolic execution graph*
• Fayyazi and others, 2019, qEC A Logical Equivalence Checking Framework Targeting SFQ Superconducting Circuits
• Brunese and others, 2019, Radiomic Features for Medical Images Tamper Detection by Equivalence Checking
• Bhowmik and Do, 2019, Refinement and resolution of just-in-time requirements in open source software and a closer look into non-functional requirements
• Tahat and others, 2019, Scalable Translation Validation of Unverified Legacy OS Code
• Churchill and others, 2019, Semantic program alignment for equivalence checking
• Damljanovic and others, 2019, Simulation-based Equivalence Checking between IEEE 1687 ICL and RTL
• Tian, 2019, Smart Contract Defect Detection Based on Parallel Symbolic Execution
• Loring and others, 2019, Sound regular expression semantics for dynamic symbolic execution of JavaScript
• Husák and Zavoral, 2019, Source code assertion verification using backward symbolic execution
• Păsăreanu and others, 2019, Symbolic Execution and Recent Applications to Worst-Case Execution, Load Testing, and Security Analysis
• Ahmed and Safar, 2019, Symbolic Execution based Verification of Compliance with the ISO 26262 Functional Safety Standard
• Fülöp and Pataki, 2019, Symbolic Execution with Finite State Automata
• Baresi and others, 2019, Symbolic execution-driven extraction of the parallel execution plans of Spark applications
• Sheng and others, 2019, Towards the Mechanized Semantics and Refinement of UML Class Diagrams
• Bossard and Kaneko, 2019, UCEJ Database Refinement and Applicability Proof
• Nivethithaa and Krishnapriya, 2018, A BRIEF SURVEY ON SYMBOLIC EXECUTION TEST-SELECTION TECHNIQUES
• Mimouni and Bouhdadi, 2018, A Mechanized Formal Refinement Proof of Modbus Communication Using Event-B Proof System
• Mutluergil and Tasiran, 2018, A mechanized refinement proof of the Chase-Lev deque using a proof system
• Pengő, 2018, Applying Heuristics to Improve our Java Symbolic Execution Engine
• Ardeshir-Larijani and others, 2018, Automated Equivalence Checking of Concurrent Quantum Systems
• Trabish and others, 2018, Chopped symbolic execution
• Mora and others, 2018, Client-specific equivalence checking
• Gerasimov and others, 2018, Combining dynamic symbolic execution, code static analysis and fuzzing
• Banerjee and Karfa, 2018, Compiler-agnostic Translation Validation
• Liang and others, 2018, Deobfuscation of Virtualization-Obfuscated Code Through Symbolic Execution and Compilation Optimization
• Ye and others, 2018, Detecting MPI Usage Anomalies via Partial Program Symbolic Execution
• Gerasimov, 2018, Directed Dynamic Symbolic Execution for Static Analysis Warnings Confirmation
• Gerasimov, 2018, Directed dynamic symbolic execution of programs to confirm errors in programs
• Gupta and others, 2018, Effective Use of SMT Solvers for Program Equivalence Checking Through Invariant-Sketching and Query-Decomposition
• Zheng and others, 2018, Efficient and Scalable Graph Parallel Processing With Symbolic Execution
• Kuehlmann and Somenzi, 2018, Equivalence Checking
• Schlesinger and others, 2018, Equivalence Checking for Hybrid Control Systems Modelled in Simulink
• Antoy and Hanus, 2018, Equivalence Checking of Non-deterministic Operations
• Bandyopadhyay and others, 2018, Equivalence checking of Petri net models of programs using static and dynamic cut-points
• Demba, 2018, Equivalence checking of two functional programs using inductive theorem provers
• Ahmed and Safar, 2018, Formal Verification of AUTOSAR Watchdog Manager Module Using Symbolic Execution
• Liu and others, 2018, MC/DC coverage-oriented compiler optimization for symbolic execution
• Khalil and Dingel, 2018, Optimizing the Symbolic Execution of Evolving Rhapsody Statecharts
• Benton, 2018, Semantic Equivalence Checking for HHVM Bytecode
• Bultan, 2018, Side-Channel Analysis via Symbolic Execution and Model Counting
• Douglas and Krishnamoorthy, 2018, Static Analysis and Symbolic Execution for Deadlock Detection in MPI Programs
• Romero and Rocha, 2018, Symbolic Execution and Reachability Analysis Using Rewriting Modulo SMT for Spatial Concurrent Constraint Systems with Extrusion
• Alatawi and others, 2018, Symbolic Execution with Invariant Inlay Evaluating the Potential
• Hentschel and others, 2018, The Symbolic Execution Debugger SED a platform for interactive symbolic execution, debugging, verification and more
• Qiu and others, 2018, Using Test Ranges to Improve Symbolic Execution
• Abadi and others, 2018, Verifying Parallel Code After Refactoring Using Equivalence Checking
• Shan and others, 2017, A Detecting Method of Array Bounds Defects Based on Symbolic Execution
• Ain and others, 2017, A Framework for Automated Feature Based Mixed-Signal Equivalence Checking
• Lucanu and others, 2017, A generic framework for symbolic execution A coinductive approach
• Zhang and Thing, 2017, A hybrid symbolic execution assisted fuzzing method
• Yanase, 2017, Abstraction refinement for non-zeno fairness verification of linear hybrid automata
• Schmitt and others, 2017, Adaptive Code Refinement A Compiler Technique and Extensions to Generate Self-Tuning Applications
• Banerjee and others, 2017, An Equivalence Checking Framework for Array-Intensive Programs
• Baldoni and others, 2017, Assisting Malware Analysis with Symbolic Execution A Case Study
• Goli and others, 2017, Automatic equivalence checking for SystemC-TLM 2.0 models against their formal specifications
• Dahiya and Bansal, 2017, Black-Box Equivalence Checking Across Compiler Optimizations
• Braione and others, 2017, Combining symbolic execution and search-based testing for programs with complex heap inputs
• Shupletsov and Avtaikina, 2017, Dynamic programming algorithms for large-scale equivalence checking and functional correction
• Li and others, 2017, Dynamic symbolic execution for polymorphism
• Vartanov, 2017, Dynamic symbolic execution of Java programs using JNI
• Finkbeiner and others, 2017, EAHyper Satisfiability, Implication, and Equivalence Checking of Hyperproperties
• 2017, Equivalence Checking
• Okano and others, 2017, Equivalence Checking of Java Methods Toward Ensuring IoT Dependability
• Pengő and Siket, 2017, Improving Static Initialization Block Handling in Java Symbolic Execution Engine
• Liang and others, 2017, Improving the precision of static analysis Symbolic execution based on GCC abstract syntax tree
• Sheng and others, 2017, Mechanized semantics and refinement of UML-Statecharts
• Qinhao Wang and others, 2017, Methods of equivalence checking and ECO support under C-based design through reproduction of C descriptions from implementation designs
• Fu and others, 2017, On Equivalence Checking of Nondeterministic Finite Automata
• Lai, 2017, Proof of a refinement of Blum’s conjecture on hexagonal dungeons
• Sumners, 2017, Proof Reduction of Fair Stuttering Refinement of Asynchronous Systems and Applications
• Weinstein, 2017, Refinement Invariants of Binary Images
• Vasicek, 2017, Relaxed equivalence checking a new challenge in logic synthesis
• Bandyopadhyay and others, 2017, SamaTulyata An Efficient Path Based Equivalence Checking Tool
• Pasareanu, 2017, Symbolic execution and probabilistic reasoning
• Moreno and others, 2017, Symbolic Execution and Thresholding for Efficiently Tuning Fuzzy Logic Programs
• Guo and others, 2017, Symbolic execution of programmable logic controller code
• Boudhiba and others, 2017, Symbolic Execution of Transition Systems with Function Summaries
• Chang and others, 2017, Symbolic types for lenient symbolic execution
• 2017, Testing-Based Translation Validation of Generated Code
• Bejenaru, 2017, The multilinear restriction estimate a short proof and a refinement
• Kádár, 2017, The Optimization of a Symbolic Execution Engine for Detecting Runtime Errors
• Barthe and others, 2017, Verified Translation Validation of Static Analyses
• Scheurer and others, 2016, A General Lattice Model for Merging Symbolic Execution Branches
• König and Küpper, 2016, A generalized partition refinement algorithm, instantiated to language equivalence checking for weighted automata
• Mutluergil and Tasiran, 2016, A Mechanized Refinement Proof of the Chase-Lev Deque Using a Proof System
• Dross and Moy, 2016, Abstract Software Specifications and Automatic Proof of Refinement
• Bandyopadhyay and others, 2016, An efficient path based equivalence checking for Petri net based models of programs
• Dutta and Sarkar, 2016, An Enhanced Equivalence Checking Method to Handle Bugs in Programs with Recurrences
• Qiu and others, 2016, Certified Symbolic Execution
• Banescu and others, 2016, Code obfuscation against symbolic execution attacks
• Dernehl and others, 2016, Combining Abstract Interpretation with Symbolic Execution for a Static Value Range Analysis of Block Diagrams
• Lin and others, 2016, Compositional Symbolic Execution Incremental Solving Revisited
• Babin and others, 2016, Correct Instantiation of a System Reconfiguration Pattern A Proof and Refinement-Based Approach
• Jasper, 2016, Counterexample-Guided Prefix Refinement Analysis for Program Verification
• Wu and others, 2016, Design partitioning for large-scale equivalence checking and functional correction
• Hamaya and Yamane, 2016, Detecting bank conflict of GPU programs using symbolic execution
• Ming and others, 2016, Deviation-Based Obfuscation-Resilient Program Equivalence Checking With Application to Software Plagiarism Detection
• Kuehlmann and others, 2016, Equivalence Checking
• Jian Hu and others, 2016, Equivalence checking between SLM and RTL using machine learning techniques
• Goldberg, 2016, Equivalence checking by logic relaxation
• Mukherjee and others, 2016, Equivalence Checking of a Floating-Point Unit Against a High-Level C Model
• Demba, 2016, Equivalence Checking of Two Functional Programs Using Inductive Theorem Provers
• Thole and others, 2016, Equivalence checking on ESL utilizing a priori knowledge
• Sayed-Ahmed and others, 2016, Equivalence checking using Gröbner bases
• Li and Kobayashi, 2016, Equivalence-Based Abstraction Refinement for HORS Model Checking
• Amarú and others, 2016, Exploiting Inherent Characteristics of Reversible Circuits for Faster Combinational Equivalence Checking
• Hasabnis and Sekar, 2016, Extracting instruction semantics via symbolic execution of code generators
• Rabiah and Belkhouche, 2016, Formal specification, refinement, and implementation of path planning
• Behnam and others, 2016, Formally analyzing fault tolerance in datapath designs using equivalence checking
• Chen and others, 2016, Generating performance distributions via probabilistic symbolic execution
• Feist and others, 2016, Guided Dynamic Symbolic Execution Using Subgraph Control-Flow Information
• Amaru, 2016, Improvements to the Equivalence Checking of Reversible Circuits
• Aissat and others, 2016, Infeasible Paths Elimination by Symbolic Execution Techniques
• Zakharov and Temerbekova, 2016, ON THE MINIMIZATION AND EQUIVALENCE CHECKING OF SEQUENTIAL REACTIVE SYSTEMS
• Drozdov and others, 2016, Petri nets behavioral equivalence checking in SMV
• Xia, 2016, Property preservation of refinement for Petri net based representation for embedded systems
• Pfeffer and others, 2016, Protecting Legacy Code against Control Hijacking via Execution Location Equivalence Checking
• Hensel and others, 2016, Proving Termination of Programs with Bitvector Arithmetic by Symbolic Execution
• Schuts and others, 2016, Refactoring of Legacy Software Using Model Learning and Equivalence Checking An Industrial Experience Report
• Lammich, 2016, Refinement based verification of imperative data structures
• O’Connor and others, 2016, Refinement through restraint bringing down the cost of verification
• Azarbad and Alizadeh, 2016, Scalable SMT-Based Equivalence Checking of Nested Loop Pipelining in Behavioral Synthesis
• Arcaini and others, 2016, SMT-Based Automatic Proof of ASM Model Refinement
• Beyer and Lemberger, 2016, Symbolic Execution with CEGAR
• Sneed and Verhoef, 2016, Validating Converted Java Code via Symbolic Execution
• Seiter and others, 2016, Verification of Horizontal Refinement
• Bandyopadhyay and others, 2015, A Path-based Equivalence Checking Method for Petri Net based Models of Programs
• Banerjee and others, 2015, A translation validation framework for symbolic value propagation based equivalence checking of FSMDAs
• Castro Marquez and others, 2015, A Unified Sequential Equivalence Checking Methodology to Verify RTL Designs with High-Level Functional and Protocol Specification Models
• Hao and Shuitao, 2015, Achieve Fuzzing Based on Symbolic Execution Platform
• Saglamdemir and others, 2015, An analog behavioral equivalence checking methodology for simulink models and circuit level designs
• Ibing, 2015, Architecture Description Language Based Retargetable Symbolic Execution
• Muntean and others, 2015, Automated Generation of Buffer Overflow Quick Fixes Using Symbolic Execution and SMT
• Lopes and Monteiro, 2015, Automatic equivalence checking of programs with uninterpreted functions and integer arithmetic
• Leung and others, 2015, C-to-Verilog translation validation
• Lin and others, 2015, Compositional Symbolic Execution Using Fine-Grained Summaries
• Cimatti and Tonetta, 2015, Contracts-refinement proof system for component-based embedded systems
• Ball Thomas and Daniel Jakub, 2015, Deconstructing Dynamic Symbolic Execution
• Bhowmik and others, 2015, Directed Symbolic Execution for VLSI Circuits
• Adachi and others, 2015, Distributed CFG-based symbolic execution for assembly programs
• Song and others, 2015, Enhancing Conformance Testing Using Symbolic Execution for Network Protocols
• Hu and others, 2015, Equivalence checking between SLM and TLM using coverage directed simulation
• Oliveira and others, 2015, Equivalence checking for comparing user interfaces
• Li and others, 2015, Equivalence checking of scheduling in high-level synthesis
• Thole and others, 2015, Equivalence Checking on System Level Using a Priori Knowledge
• Zakharov, 2015, Equivalence Checking Problem for Finite State Transducers over Semigroups
• Kumar and others, 2015, Equivalence Checking using Assertion based Technique
• Mukherjee and others, 2015, Equivalence Checking Using Trace Partitioning
• Cseppento and Micskei, 2015, Evaluating Symbolic Execution-Based Test Tools
• Baluda, 2015, EvoSE evolutionary symbolic execution
• Hu and others, 2015, Formal equivalence checking between SLM and RTL descriptions
• Babin and others, 2015, Formal Verification of Runtime Compensation of Web Service Compositions A Refinement and Proof Based Proposal with Event-B
• Sekanina and Vašíček, 2015, Functional Equivalence Checking for Evolution of Complex Digital Circuits
• Hsu and others, 2015, ICCAD-2015 CAD contest in large-scale equivalence checking and function correction and benchmark suite
• Johnson and others, 2015, Improvement, Verification, and Refinement of Spatially-Explicit Exposure Models in Risk Assessment - FishRand Spatially-Explicit Bioaccumulation Model Demonstration
• Delahaye and others, 2015, Infeasible path generalization in dynamic symbolic execution
• Saifhashemi and others, 2015, Logical Equivalence Checking of Asynchronous Circuits using Commercial Tools
• Lin and Miller, 2015, Looking Closer at Compositional Symbolic Execution
• Duan and others, 2015, Model Checking MSVL Programs Based on Dynamic Symbolic Execution
• Ngo and others, 2015, Modular translation validation of a full-sized synchronous compiler using off-the-shelf verification tools
• Zakharov and Podymov, 2015, On the application of equivalence checking algorithms for program minimization
• Rakadjiev and others, 2015, Parallel SMT Solving and Concurrent Symbolic Execution
• Nowack and others, 2015, Parallel Symbolic Execution Merging In-Flight Requests
• Raychev and others, 2015, Parallelizing user-defined aggregations using symbolic execution
• Jun-xian and others, 2015, PathWalker A Dynamic Symbolic Execution Tool Based on LLVM Byte Code Instrumentation
• Bandyopadhyay and others, 2015, Poster An Efficient Equivalence Checking Method for Petri Net Based Models of Programs
• Marcozzi and others, 2015, Relational symbolic execution of SQL code for unit testing of database programs
• Dai and others, 2015, Sequential equivalence checking of clock-gated circuits
• Muntean and others, 2015, SMT-constrained symbolic execution engine for integer overflow detection in C code
• Chen and Kim, 2015, STAR Stack Trace Based Automatic Crash Reproduction via Symbolic Execution
• Dong and others, 2015, Studying the influence of standard compiler optimizations on symbolic execution
• Vidal, 2015, Symbolic execution as a basis for termination analysis
• Yadegari and Debray, 2015, Symbolic Execution of Obfuscated Code
• Cadar, 2015, Targeted program transformations for symbolic execution
• Anwer, 2015, Testing Program for Security using Symbolic Execution and Exception Injection
• Vidal, 2015, Towards Symbolic Execution in Erlang
• Hernandez and others, 2015, Transformations on the FSMD of the RTL code with combinational logic statements for equivalence checking of HLS
• Ngo and others, 2015, Translation Validation for Clock Transformations in a Synchronous Compiler
• Chan Ngo and others, 2015, Translation Validation for Synchronous Data-Flow Specification in the SIGNAL Compiler
• Banerjee and others, 2015, Translation Validation of Transformations of Embedded System Specifications Using Equivalence Checking
• Kafle and Gallagher, 2015, Tree Automata-Based Refinement with Application to Horn Clause Verification
• Wehrheim and Travkin, 2015, TSO to SC via Symbolic Execution
• Alatawi and others, 2015, Using Metamorphic Testing to Improve Dynamic Symbolic Execution
• Asada and others, 2015, Verifying Relational Properties of Functional Programs by First-Order Refinement

Verified compilation preserves semantics and says nothing about cost

A verified compiler is one whose correctness has itself been proven mathematically, which is a formidable achievement and a narrower one than it sounds. Leroy 2009a and Leroy 2009b establish CompCert, the best known example. Leroy and Blazy 2008 give the model of memory that underpins it, and Kumar et al. 2014b establish CakeML on the same principle.

None of these claims resource preservation and none is careless about saying so. The theorems are about observable behaviour. A project that reads “verified compiler” as “my bounds survive” has imported a guarantee that was never offered, which is the misreading Result 1 makes concrete rather than a strawman.

Necula 1997 gives the shape the eventual answer probably takes, in which the artefact carries machine-checkable evidence about itself, and that is what this project’s plan to export a memory requirement as a linker symbol already gestures at without yet having anything sound to put in it.

100 contemporary records extend this work, and not one of their titles claims resource preservation. The cluster is roughly a fifth the size of the timing cluster, which is worth noticing, since verifying a compiler is the harder achievement and the smaller literature.

• Jia and others, 2026, An Empirical Framework for Evaluating Semantic Preservation Using Hugging Face
• Lasnier and others, 2026, Brack A Verified Compiler for Scheme via CakeML
• Zhao and others, 2026, Code Representation for AI-Driven Vulnerability Detection Oriented to Semantic Preservation and Model Adaptation
• Lin and others, 2026, Let It Flow A Formally Verified Compilation Framework for Asynchronous Dataflow
• Lion and Broman, 2026, Making Time Observable Compiler Correctness for Real-Time C Programs
• Rinard, 2026, Testing, Credible Compilation, and Verification in the Axon Verified Compiler in Lean and Claude Code
• NOOR AZMI and Mohamed Hanum, 2026, TEXTUAL ADVERSARIAL EXAMPLE GENERATION USING BIGRAM UNIGRAM-SEMANTIC PRESERVATION OPTIMIZATION ALGORITHM
• Nezamabadi and others, 2026, Verified VCG and Verified Compiler for Dafny
• Su and Colvin, 2026, Weak Memory Model Formalisms Introduction and Survey
• Zaliva and others, 2025, A CHERI C Memory Model for Verified Temporal Safety
• 2025, Background on the CompCert Compiler
• Patil and Redekar, 2025, Enhancing Neural Style Transfer for Multi-Style and Semantic Preservation
• Jamner and others, 2025, Pyrosome Verified Compilation for Modular Metatheory
• Chen, 2025, Semantic preservation and stylistic decoupling in textual style migration
• Gao and Dong, 2025, Stealthier Backdoor Attacks for Multimodal Models Bidirectional Triggers via Coverless Steganography and Semantic Preservation
• Yu and others, 2025, Text Detoxification Data Efficiency, Semantic Preservation and Model Generalization
• Chen and others, 2025, Time-Frequency-Based Attention Cache Memory Model for Real-Time Speech Separation
• Girault, 2025, Toward a Formally Verified Compiler for a Synchronous, Functional, Data-Flow Programming Language
• Melquiond and Moreau, 2024, A Safe Low-Level Language for Computer Algebra and Its Formally Verified Compiler
• Liu and others, 2024, A Verified Compiler for a Functional Tensor Language
• Mansky and Du, 2024, An Iris Instance for Verifying CompCert C Programs
• Blazy, 2024, From Mechanized Semantics to Verified Compilation the Clight Semantics of CompCert
• Zhang and others, 2024, Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules
• Monniaux, 2024, Memory Simulations, Security and Optimization in a Verified Compiler
• Loitzl and Zuleger, 2024, Modeling Register Pairs in CompCert
• Chavanon and others, 2024, PfComp A Verified Compiler for Packet Filtering Leveraging Binary Decision Diagrams
• Monniaux, 2024, Pragmatics of formally verified yet efficient static analysis, in particular, for formally verified compilers
• Zuo and others, 2024, Semantic Security A Digital Watermark Method for Image Semantic Preservation
• Heryadi and others, 2023, Aspect-based Sentiment Analysis using Long Short-term Memory Model for Leveraging Restaurant Service Management
• Cruz-Filipe and others, 2023, Certified Compilation of Choreographies with hacc
• Blazy, 2023, CompCert A Journey through the Landscape of Mechanized Semantics for Verified Compilation Keynote
• Kuepper and others, 2023, CryptOpt Verified Compilation with Randomized Program Search for Cryptographic Primitives
• Chao and others, 2023, Data augmentation for sentiment classification with semantic preservation and diversity
• Awasthi, 2023, Deployment of Formal Verification Methodology for AXI based Protocol for a Memory Model Verification
• Barrière and others, 2023, Formally Verified Native Code Generation in an Effectful JIT Turning the CompCert Backend into a Formally Verified JIT Compiler
• Gourdin, 2023, Lazy Code Transformations in a Formally Verified Compiler
• Barroso and others, 2023, Leroy and Blazy Were Right Their Memory Model Soundness Proof is Automatable
• Kanabar and others, 2023, PureCake A Verified Compiler for a Lazy Functional Language
• Monniaux and others, 2023, Testing a Formally Verified Compiler
• Derakhshan and others, 2023, Towards End-to-End Verified TEEs via Verified Interface Conformance and Certified Compilers
• Bourke and others, 2023, Verified Compilation of Synchronous Dataflow with State Machines
• Zhao and Du, 2023, Video colorization with semantic preservation and consistency
• Han and others, 2022, Demographical Analysis of US Homelessness and Predictions Based on Long Short-Term Memory Model
• Monniaux and Boulmé, 2022, The Trusted Computing Base of the CompCert Verified Compiler
• Wang and others, 2022, Verified compilation of C programs with a nominal memory model
• Li and others, 2022, Verified compilation of Quantum oracles
• Gómez-Londoño and Myreen, 2021, A flat reachability-based measure for CakeML’s cost semantics
• Abate and others, 2021, An Extended Account of Trace-relating Compiler Correctness and Secure Compilation
• Xia and others, 2021, Deep hash image retrieval based on supervised semantic preservation
• Mével and Jourdan, 2021, Formal verification of a concurrent bounded queue in a weak memory model
• Hsiao and others, 2021, Synthesizing Formal Models of Hardware from RTL for Efficient Verification of Memory Model Implementations
• Chen and others, 2021, TM-HOL Topic memory model for detection of hate speech and offensive language
• Chhak and others, 2021, Towards formally verified compilation of tag-based policy enforcement
• Jain, 2021, WebAssembly Module Internals Sections and Memory Model
• Lu and others, 2020, Attentive Semantic Preservation Network for Zero-Shot Learning
• Almeida and others, 2020, Certified Compilation for Cryptography Extended x86 Instructions and Constant-Time Verification
• Blazy, 2020, From Verified Compilation to Secure Compilation a Semantic Approach
• Conchon and others, 2020, Parameterized Model Checking on the TSO Weak Memory Model
• Abrahamsson and others, 2020, Proof-Producing Synthesis of CakeML from Monadic HOL Functions
• Song and others, 2019, CompCertM CompCert with C-assembly linking and lightweight modular verification
• Becker and others, 2019, Icing Supporting Fast-Math Style Optimizations in a Verified Compiler
• Lindgren and others, 2019, Introducing Certified Compilation in Education by a Functional Language Approach
• Bourke and others, 2019, Mechanized semantics and verified compilation for a dataflow synchronous language with reset
• Patterson and Ahmed, 2019, The next 700 compiler correctness theorems functional pearl
• KIAM TAN and others, 2019, The verified CakeML compiler backend
• Lööw and others, 2019, Verified compilation on a verified processor
• Dong, 2018, A sound abstract memory model for static analysis of C programs
• Hupel and Nipkow, 2018, A Verified Compiler from Isabelle/HOL to CakeML
• Annenkov and Elsman, 2018, Certified Compilation of Financial Contracts
• Trippel and others, 2018, Full-Stack Memory Model Verification with TriCheck
• Lochbihler, 2018, Mechanising a Type-Safe Model of Multithreaded Java with a Verified Compiler
• Ho and others, 2018, Proof-Producing Synthesis of CakeML with I/O and Local State from Monadic HOL Functions
• Hjort and others, 2018, The CakeML Compiler Explorer
• Zakowski and others, 2018, Verified compilation of linearizable data structures
• Gurfinkel and Navas, 2017, A Context-Sensitive Memory Model for Verification of C/C++ Programs
• Bourke and others, 2017, A formally verified compiler for Lustre
• Besson and others, 2017, A Verified CompCert Front-End for a Memory Model Supporting Pointer Arithmetic and Uninitialised Data
• Maleehuan and others, 2017, Assembly program verification for multiprocessors with relaxed memory model using SMT solver
• Banks and others, 2017, Verification of a lazy cache coherence protocol against a weak memory model
• Fox and others, 2017, Verified compilation of CakeML to multiple machine-code targets
• Amy and others, 2017, Verified Compilation of Space-Efficient Reversible Circuits
• Fournet and others, 2016, A Certified Compiler for Verifiable Computing
• Krebbers, 2016, A Formal C Memory Model for Separation Logic
• Tan and others, 2016, A new verified compiler backend for CakeML
• Cabon and others, 2016, An Extended Buffered Memory Model With Full Reorderings
• Liu and Zhang, 2016, Static memory leak detection based on a new memory model
• Lindgren and others, 2016, Towards certified compilation of RTFM-core applications
• Mullen and others, 2016, Verified peephole optimizations for CompCert
• Yanagisawa, 2016, Wait-Free Solvability of Colorless Tasks in Anonymous Shared-Memory Model
• Besson and others, 2015, A Concrete Memory Model for CompCert
• Eberl and others, 2015, A Verified Compiler for Probability Density Functions
• Tan and others, 2015, A verified type system for CakeML
• Vafeiadis and others, 2015, Common Compiler Optimisations are Invalid in the C11 Memory Model and what we can do about it
• Stewart and others, 2015, Compositional CompCert
• Vafeiadis, 2015, Formal Reasoning about the C11 Weak Memory Model
• Meshman and others, 2015, Pattern-based synthesis of synchronization for the C++ memory model
• Neis and others, 2015, Pilsner a compositionally verified compiler for a higher-order imperative language
• Dong, 2015, RSTVL A Sound Abstract Memory Model for Program Static Analysis
• Zhang, 2015, SIRe an efficient snapshot isolation-based memory model for detecting and tolerating region conflicts
• Yang and others, 2015, Towards a verified compiler prototype for the synchronous language SIGNAL

Bounded execution in deployed systems, which is where the practice is

Regehr et al. 2005 eliminate stack overflow by abstract interpretation of machine code, and Brylow et al. 2001 check interrupt-driven assembly for stack bounds directly. Both make the same choice, which is to analyse the thing that executes.

For the bytecode-then-native configuration specifically, Gershuni et al. 2019 give a static analysis for untrusted Linux kernel extensions, which is the research counterpart of the eBPF verifier discussed above. That system fixes a stack cap rather than transferring a computed bound, and the commercial tools StackAnalyzer and aiT recompute from the binary against a target model, because ISO 26262 and its siblings ask for evidence about the executable.

Sandboxed and isolated execution accounts for 295 contemporary records.

• 2026, A Hybrid JavaScript-WebAssembly Framework for Efficient Deep Learning Inference in Web Browsers
• Heinrich and others, 2026, A Method for Detecting Anomalies in WebAssembly Using Categorical Data
• Fitz, 2026, A Sandboxing Canvas for Value-Sensitive Designs of Launching Digital Platforms
• Corrias and others, 2026, An Analysis of Modern Web Security Vulnerabilities Inside WebAssembly Applications
• Draissi and Davi, 2026, Bento Fine-Grained Memory Isolation for COTS WebAssembly Binaries
• Shortt and others, 2026, Bounding the Execution Cost of WebAssembly Functions
• 2026, CryptX WebAssembly and CPU Behavior Based detection extension
• Kwon and others, 2026, eBPF-VulnBench A Benchmark of Real-World eBPF Malicious Bytecode
• Israel and others, 2026, Exploring WebAssembly as a Runtime Platform for Safety-Critical Edge Systems
• Kim and Kim, 2026, From Ops to Dev A Dual-Layer Programmable Data Lake With Kubernetes and WebAssembly-Based Offloading
• Khan, 2026, Hybrid Mobile Threat Analytics Boosting Android Malware Classification via Integrated Static-Dynamic Sandboxing
• Kärkkäinen and others, 2026, Implementing Liquid Software with WebAssembly
• Weber and others, 2026, Lightweight WebAssembly-Based Intrusion Detection for Zero Trust Edge Networks
• Stepanov and Klym, 2026, Parallelism and WebAssembly memory management in microinterface architecture
• Vasić, 2026, RAZVOJ SAVREMENIH VEB APLIKACIJA U .NET EKOSISTEMU PRIMENOM WEBASSEMBLY I BLAZOR TEHNOLOGIJA
• Baradaran and others, 2026, Reusing Legacy Code in Wasm Key Challenges of Compilation and Code Semantics Preservation
• Choi and Jeon, 2026, Stack-based static WebAssembly binary slicing and mutation for generating valid sub-binaries
• Parra, 2026, SurtGIS A high-performance raster geospatial analysis library in Rust with WebAssembly and Python support
• Pilla, 2026, Sweat2Scroll An Energy-Efficient Policy Enforcement Architecture for Mobile Edge Environments Using WebAssembly
• Moon and others, 2026, The Blind Spot of Extension Security WebAssembly-JavaScript Collaborative Attacks on Chrome
• Blaak and Van Cutsem, 2026, Towards Least-Privilege WebAssembly Applications Transparent Interposition for WebAssembly Components
• Liu and others, 2026, WAB Overcoming Memory, Network, and Security Walls in Native Agentic Browsers with WebAssembly
• Shin and others, 2026, WARD Efficient Memory Protection for WebAssembly on Tiny Embedded Systems
• Massey and Olivier, 2026, WASP Stack protection for WebAssembly
• Elijah and Shalan, 2026, WebAssembly Based AI-Driven Framework for Zero-day Exploit Detection
• Zhu and others, 2026, WebAssembly-Based Runtime Fault Isolation and Safety Control for UAV Visual-Inertial State Streams
• 2025, 2 Sandboxing from therapeutic practice to qualitative data generation
• 2025, 3 Sandboxing in practice
• 2025, 4 Sandboxing adaptions and developments
• Stepanov and Klym, 2025, A QUANTITATIVE ANALYSIS OF WEBASSEMBLY INTEGRATION ARCHITECTURAL PATTERNS, TOOLING, AND PERFORMANCE EVALUATION
• Moskalenko, 2025, Application of WebAssembly for High-Performance Client-Side Media Content Analysis
• Ramesh Prasad Pokhrel, 2025, Behavioral analysis of malware using sandboxing techniques
• Moron and Wallentowitz, 2025, Benchmarking WebAssembly for Embedded Systems
• Mahdhi, 2025, Blazor WebAssembly Full-Stack Web Development
• Khairoowala and others, 2025, Browser-Based Customer Churn Prediction using WebAssembly Pyodide
• Watt, 2025, Concurrency in WebAssembly
• Subramanyan, 2025, CWAMR REIMAGINING A CAPABILITYBASED WEBASSEMBLY RUNTIME VIA CHERI-BASED COMPARTMENTALIZATION
• Mannay, 2025, Difficulties with diversity reflections on representation in sandboxing studies
• Nam and Im, 2025, Enhancing Browser Physics Simulations WebAssembly and Multithreading Strategies
• Anand and others, 2025, Enhancing intrusion detection against denial of service and distributed denial of service attacks Leveraging extended Berkeley packet filter and machine learning algorithms
• Stanley and Eide, 2025, Finding Bugs in WebAssembly Interface Type Binding Generators
• Shachnai and others, 2025, Fixing Latent Unsound Abstract Operators in the eBPF Verifier of the Linux Kernel
• Wu and others, 2025, Flow Hijacking in eBPF Exploitation and Mitigation Across both Interpreter and JIT Execution
• Kröning and others, 2025, From Browser to Kernel Exploring a Lightweight Sandboxed Approach for Unikernel Extensions
• Solleza and others, 2025, Kernel Extension DSLs Should Be Verifier-Safe!
• Jadidi and Anderson, 2025, Leash A Transparent Capability-Based Sandboxing Supervisor for Unix
• Shafi Shaik, 2025, Leveraging WebAssembly in Micro Frontend Architectures A Technical Deep Dive
• Jansen and others, 2025, Memory Efficient WebAssembly Containers
• Muniyandi, 2025, Multi-Tenant SaaS Performance Isolation Using Container-Based Resource Sandboxing
• Zaeske and others, 2025, On the Design of a WebAssembly Interpreter for Safety Critical Avionics Applications
• Xu and others, 2025, Optimizing Type Duplication in WebAssembly Module Splitting
• Kakati and Brorsson, 2025, Performance and Usability Implications of Multiplatform and WebAssembly Containers
• MIDZIC and NOVAK, 2025, Performance Comparison of WebAssembly and Phaser in Procedural Maze Generation
• Jiang and Hua, 2025, PowerPoly Analyzing Multilingual Programs with the Aid of WebAssembly
• Litvinavicius, 2025, Practice Tasks for Client WebAssembly Blazor
• Wei and others, 2025, Reconstructing Continuation-Passing Semantics for WebAssembly
• Soluian and Lіushenko, 2025, Research of WebAssembly usage for high-performance code development in web applications
• Zhang and others, 2025, Research on Efficient Packet Filter Technology Based on eBPF
• 2025, Research on Malicious Code Detection Technology for Binary and WASM Bytecode Files in Web3.0 Distributed Applications
• Park and others, 2025, RGFuzz Rule-Guided Fuzzer for WebAssembly Runtimes
• Marcelino and others, 2025, Roadrunner Accelerating Data Delivery to WebAssembly-Based Serverless Functions
• Yang and others, 2025, Runtime Verification for Linux Kernel Based on eBPF
• Kitatani and others, 2025, Sandboxing Building OS Enabling Isolated Development Environment for Smart Buildings
• Mannay and Timperley, 2025, Sandboxing in practice
• Mannay and Timperley, 2025, Sandboxing adaptions and developments
• Kelly and Fuh, 2025, Sandboxing Foolproof Boundaries vs. Unbounded Foolishness
• Mannay and Timperley, 2025, Sandboxing from therapeutic practice to qualitative data generation
• Satya Teja Muddada, 2025, Serverless 2.0 Unlocking Performance and Portability with WebAssembly
• Seweryn, 2025, The Efficiency of Rust and WebAssembly Compared to Plain JavaScript
• Jiang and Hua, 2025, WasmSepa Effectively Protecting WebAssembly Through Privilege Separation
• Wang and others, 2025, WAVEN WebAssembly Memory Virtualization for Enclaves
• Perrone and Romano, 2025, WebAssembly and security A review
• Wang and Prakash, 2025, WebAssembly Memory Tagging
• Karpovich and Gosudarev, 2025, WebAssembly performance in the Node.js environment
• Titzer, 2025, WebAssembly How Low Can a Bytecode Go?
• Wingo, 2025, WebAssembly Yes, but for What?
• Draissi and others, 2025, Wemby’s Web Hunting for Memory Corruption in WebAssembly
• Ehrenberg, 2025, When Is WebAssembly Going to Get DOM Support?
• Doyle, 2025, Why devotion mandates self-transcendence against ostriching and sandboxing
• КОЗУБ and others, 2025, АНАЛІЗ ВПЛИВУ WEBASSEMBLY НА ПРОДУКТИВНІСТЬ СКЛАДНИХ ВЕБЗАСТОСУНКІВ
• Heinrich and others, 2024, A Categorical Data Approach for Anomaly Detection in WebAssembly Applications
• Klehm and others, 2024, A comparative analysis between Lua interpreter variants compiled to WASM, JavaScript and native
• Kakati and Brorsson, 2024, A Cross-Architecture Evaluation of WebAssembly in the Cloud-Edge Continuum
• Hoff, 2024, A Few Doubts about Sandboxing AI Operations
• 2024, A Study on the Application of Sandboxing in Blended Learning An Example of Cost Accounting
• Kim and others, 2024, Accelerating Embedded WebAssembly Based on FPGA
• Rupp and others, 2024, Accelerating WebAssembly Interpreters in Embedded Systems Through Hardware-Assisted Dispatching
• Massidda and others, 2024, Bringing Binary Exploitation at Port 80 Understanding C Vulnerabilities in WebAssembly
• Georges and others, 2024, Cerise Program Verification on a Capability Machine in the Presence of Untrusted Code
• 2024, Chapter 1 WebAssembly Introduction
• Qin and others, 2024, Characterizing Dynamic Memory Behavior in WebAssembly Workloads
• Markov and others, 2024, COMPETITIVE PROGRAMMING PLATFORM AND METHODS OF SAFELY EXECUTING UNTRUSTED CODE
• Kotilainen and others, 2024, Demonstrating Liquid Software in IoT Using WebAssembly
• Silva and others, 2024, Efficient Data Exchange between WebAssembly Modules
• Yuan and others, 2024, End-to-End Mechanized Proof of a JIT-Accelerated eBPF Virtual Machine for IoT
• Han and others, 2024, ESFuzzer An Efficient Way to Fuzz WebAssembly Interpreter
• Dwivedi and others, 2024, Fast, Flexible, and Practical Kernel Extensions
• Lu and others, 2024, Formalizing x86-64 ISA in Isabelle/HOL A Binary Semantics for eBPF JIT Correctness
• Kim and others, 2024, Hardware-Based WebAssembly Accelerator for Embedded System
• Fujimoto, 2024, Integrating GeoGebra with React and WebAssembly A Web-Based Approach for Mathematical Software Development
• Legoupil and others, 2024, Iris-MSWasm Elucidating and Mechanising the Security Invariants of Memory-Safe WebAssembly
• Zhang, 2024, Language-based Sandboxing
• Yedidia, 2024, Lightweight Fault Isolation Practical, Efficient, and Secure Software Sandboxing
• Perkel, 2024, No installation required how WebAssembly is changing scientific computing
• Marra and others, 2024, On the Feasibility of CubeSats Application Sandboxing for Space Missions
• Morys-Magiera and others, 2024, Portable Native Code for JavaScript Runtimes with WebAssembly, Rust and wasm-pack
• Koizumi and others, 2024, Poster Secure NFV Infrastructure based on Software Fault Isolation Considering Multi-Tenant Environment
• Mahmoud and others, 2024, Redefining Malware Sandboxing Enhancing Analysis Through Sysmon and ELK Integration
• Liu and others, 2024, Research on Front-End JavaScript Code Protection Method Based on Go Language and WebAssembly
• Fitzgibbons and others, 2024, RichWasm Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssembly
• Guan and others, 2024, Robust Grassmann manifold convex hull collaborative representation learning and its kernel extension for image set analysis
• Michaud and others, 2024, Robust Stack Smashing Protection for WebAssembly
• Alhindi and Hallett, 2024, Sandboxing Adoption in Open Source Ecosystems
• Mainas and others, 2024, Sandboxing Functions for Efficient and Secure Multi-tenant Serverless Deployments
• Himschoot, 2024, Securing Blazor WebAssembly
• Harnes and Morrison, 2024, SoK Analysis Techniques for WebAssembly
• Niemi, 2024, Survey of Real-World Process Sandboxing
• Brodeur and others, 2024, tBPF Testing Berkeley Packet Filter Programs Using User Mode Linux
• Artz, 2024, The Art of Sandboxing
• Igelsböck, 2024, The Guru, the Outside, and the Underneath Exploring Innovation Sandboxing with Innovation Theater
• Helpa and others, 2024, The Use of the DWARF Debugging Format for the Identification of Potentially Unwanted Applications PUAs in WebAssembly Binaries
• Lu and others, 2024, Towards Functional Verification of eBPF Programs
• Chintamaneni and others, 2024, Unsafe kernel extension composition via BPF program nesting
• Tyler and De Oliveira Nunes, 2024, Untrusted Code Compartmentalization for Bare Metal Embedded Devices
• Debas and others, 2024, Unveiling the Dynamic Landscape of Malware Sandboxing A Comprehensive Review
• Gerhorst and others, 2024, VeriFence Lightweight and Precise Spectre Defenses for Untrusted Linux Kernel Extensions
• Zhao and others, 2024, Wapplique Testing WebAssembly Runtime via Execution Context-Aware Bytecode Mutation
• Lauwaerts and others, 2024, WARDuino An embedded WebAssembly virtual machine
• Jiang and Hua, 2024, WaShadow Effectively Protecting WebAssembly Memory Through Virtual Machine-Aware Shadow Memory
• Cabrera-Arteaga and others, 2024, Wasm-Mutate Fast and effective binary diversification for WebAssembly
• Zhuang and others, 2024, WasmChecker Effectively Detecting WebAssembly Bugs via Static Program Analysis
• Cao and others, 2024, WASMixer Binary Obfuscation for WebAssembly
• Bauckholt and Holz, 2024, WebAssembly as a Fuzzing Compilation Target Registered Report
• Heinrich and others, 2024, WebAssembly Uma Introdução
• Park and Cho, 2024, WeBMO WebAssembly Memory Bitwise Operation Obfuscation
• Mauran and others, 2023, A Kernel Extension of the Ensemble Transform Kalman Filter
• Bicego and others, 2023, A Novel Kernel Extension for the Nearest Feature Line Classifier
• Ray, 2023, An Overview of WebAssembly for IoT Background, Tools, State-of-the-Art, Challenges, and Future Directions
• Ahmad and others, 2023, AppBox A Black-Box Application Sandboxing Technique for Mobile App Management Solutions
• Pisanò and Servetti, 2023, Audio-aware applications at the edge using in-browser WebAssembly and fingerprinting
• Romano and Wang, 2023, Automated WebAssembly Function Purpose Identification With Semantics-Aware Analysis
• Cao and others, 2023, BREWasm A General Static Binary Rewriting Framework for WebAssembly
• Stotoglou and Kaskalis, 2023, Comparative Study of JavaScript and WebAssembly Derivatives in Browser Engines
• Pockstaller and others, 2023, Comparing the Energy Consumption of WebAssembly and JavaScript in Mobile Browsers
• Vaddi and others, 2023, Computing Workspot Infection Vulnerability for Sandboxing a Business Process
• Qiao and others, 2023, Container Load Prediction Based on Extended Berkeley Packet Filter
• Stiévenart and others, 2023, Dynamic Slicing of WebAssembly Binaries
• Craun and others, 2023, Enabling eBPF on Embedded Systems Through Decoupled Verification
• Deng and others, 2023, Formal Verification Platform as a Service WebAssembly Vulnerability Detection Application
• Lyu and Rzeznik, 2023, High-Performance Web Frontend Using WebAssembly
• Novković and Golub, 2023, Improving monolithic kernel security and robustness through intra-kernel sandboxing
• Jia and others, 2023, Kernel extension verification is untenable
• Yuan and others, 2023, Making an eBPF Virtual Machine Faster on Microcontrollers Verified Optimization and Proof Simplification
• Song and others, 2023, metaSafer A Technique to Detect Heap Metadata Corruption in WebAssembly
• Zhuravchak and others, 2023, Monitoring Ransomware with Berkeley Packet Filter
• Abbadini and others, 2023, NatiSand Native Code Sandboxing for JavaScript Runtimes
• Chen and others, 2023, Network Situation Awareness Technology based on Extended Berkeley Packet Filter
• Jodogne, 2023, On the Use of WebAssembly for Rendering and Segmenting Medical Images
• Chung Seo and Kim, 2023, Portable and Efficient Implementation of CRYSTALS-Kyber Based on WebAssembly
• Abbadini and others, 2023, POSTER Leveraging eBPF to enhance sandboxing of WebAssembly runtimes
• Lun and Kancherla, 2023, Powering single-cell analyses in the browser with WebAssembly
• Nakata and others, 2023, Reducing Attack Surface with Container Transplantation for Lightweight Sandboxing
• Kritikos and Iphofen, 2023, Sandboxing
• Seo and others, 2023, Sfitag Efficient Software Fault Isolation with Memory Tagging for ARM Kernel Extensions
• Rokotyanskaya and Abramov, 2023, Studying WebAssembly and comparison of its performance with JavaScript
• Moron and Wallentowitz, 2023, Support for Just-in-Time Compilation of WebAssembly for Embedded Systems
• Zhong and others, 2023, Towards Safe AI Sandboxing DNNs-Based Controllers in Stochastic Games
• Lim and others, 2023, Unleashing Unprivileged eBPF Potential with Dynamic Sandboxing
• Zhang and others, 2023, VMCanary Effective Memory Protection for WebAssembly via Virtual Machine-assisted Approach
• Wen and Dietrich, 2023, WasmSlim Optimizing WebAssembly Binary Distribution via Automatic Module Splitting
• Johnson and others, 2023, WaVe a verifiably secure WebAssembly sandboxing runtime
• Sekigawa and others, 2023, Web Application-Based WebAssembly Container Platform for Extreme Edge Computing
• Kjorveziroski and Filiposka, 2023, WebAssembly as an Enabler for Next Generation Serverless Computing
• Cabrera-Arteaga and others, 2023, WebAssembly diversification for malware evasion
• 2023, WebAssembly für die Industrie 4.0 Sichere, skalierbare Plattformen mit Bytecode-basierten Virtuellen Maschinen
• Zaeske and others, 2023, WebAssembly in Avionics Decoupling Software from Hardware
• Kotilainen and others, 2023, WebAssembly in IoT Beyond Toy Examples
• Titzer, 2022, A fast in-place interpreter for WebAssembly
• Brodschelm and Gelderie, 2022, Application Sandboxing for Linux Desktops A User-friendly Approach
• Rodrigues and Barreiros, 2022, Aspect-Oriented Webassembly Transformation
• Kim and others, 2022, Avengers, Assemble! Survey of WebAssembly Security Solutions
• Qin and others, 2022, Characterizing WebAssembly Bytecode
• Kyriakou and Tselikas, 2022, Complementing JavaScript in High-Performance Node.js and Web Applications with Rust and WebAssembly
• Liang and others, 2022, Container Network Performance Anomaly Detection Based on Extended Berkeley Packet Filter and Machine Learning
• Kjorveziroski and others, 2022, Evaluating WebAssembly for Orchestrated Deployment of Serverless Functions
• Sharaf and others, 2022, Extended Berkeley Packet Filter An Application Perspective
• Borodin and others, 2022, FEATURES OF USING LOW-LEVEL PROCESSOR CODE USING WEBASSEMBLY
• Szewczyk and others, 2022, Leaps and bounds Analyzing WebAssembly’s performance with a focus on bounds checking
• Bhonsle and others, 2022, Linear Algebra in the Browser powered by WebAssembly
• Tsmots and Tesliuk, 2022, MODELS AND TOOLS OF THE AUTOMATED SYSTEM FOR COMPUTER NETWORK TRAFFIC INVESTIGATION USING BERKELEY PACKET FILTER
• Wallentowitz and others, 2022, Potential of WebAssembly for Embedded Systems
• Denham and Thompson, 2022, Ransomware and Malware Sandboxing
• Jodogne, 2022, Rendering Medical Images using WebAssembly
• Nakakaze and others, 2022, Retrofitting Industrial Machines with WebAssembly on the Edge
• Moric and others, 2022, Rust and Webassembly for Fast, Secure and Reliable Software
• Sazanavets, 2022, Securing Blazor WebAssembly applications
• Bastys and others, 2022, SecWasm Information Flow Control for WebAssembly
• Stiévenart and others, 2022, Static stack-preserving intra-procedural slicing of webassembly binaries
• Zhang and others, 2022, SYN Flood Attack Detection and Defense Method Based on Extended Berkeley Packet Filter
• Ortiz, 2022, Using WebAssembly to Teach Code Generation in a Compiler Design Course
• Brito and others, 2022, Wasmati An efficient static vulnerability scanner for WebAssembly
• 2022, WebAssembly across Platforms Running Native Apps in the Browser, Cloud, and Edge
• De Macedo and others, 2022, WebAssembly versus JavaScript Energy and Runtime Performance
• Wethor and Hale, 2022, “StudySandboxx A Tool for Scraping, Sandboxing, Preserving, and Preparing Interactive Web Sites for Use in Human-computer Interaction and Behavioral Studies”
• Rautaray and others, 2021, A Framework for Sandboxing of Pandemic Spread
• Koren, 2021, A Standalone WebAssembly Development Environment for the Internet of Things
• Spies and Mock, 2021, An Evaluation of WebAssembly in Non-Web Environments
• Sathya and others, 2021, An Obfuscation Technique for Malware Detection and Protection in Sandboxing
• Venkat Garikipati and Aravindhan Kurunthachalam, 2021, Cloud Workload Protection with eBPF Harnessing Extended Berkeley Packet Filter for Threat Detection
• Alamari and Chow, 2021, Computation at the Edge with WebAssembly
• Wang, 2021, Empowering Web Applications with WebAssembly Are We There Yet?
• Thalamy and others, 2021, Engineering efficient and massively parallel 3D self-reconfiguration using sandboxing, scaffolding and coating
• Jain, 2021, Extending Istio with WebAssembly
• Lyu, 2021, High-Performance Web Frontend Using WebAssembly
• Himschoot, 2021, Introduction to WebAssembly and Blazor
• De Macedo and others, 2021, On the Runtime and Energy Performance of WebAssembly Is WebAssembly superior to JavaScript yet?
• Ouyang and Hua, 2021, RusBox Towards Efficient and Adaptive Sandboxing for Rust
• Himschoot, 2021, Securing Blazor WebAssembly
• Stiévenart and others, 2021, The Security Risk of Lacking Compiler Protection in WebAssembly
• Narayan and others, 2021, Tutorial Sandboxing unsafe C code with RLBox
• Menetrey and others, 2021, Twine An Embedded Trusted Runtime for WebAssembly
• Watt and others, 2021, Two Mechanisations of WebAssembly 1.0
• Tsoupidi and others, 2021, Vivienne Relational Verification of Cryptographic Implementations in WebAssembly
• Haßler and Maier, 2021, WAFL Binary-Only WebAssembly Fuzzing with Fast Snapshots
• Jain, 2021, Wasm and Kubernetes
• Jain, 2021, Wasm Web Interface
• -, 2021, WebAssembly for High-Performance Web Applications A Study on Execution Speed and Efficiency
• Jain, 2021, WebAssembly Introduction
• Jain, 2021, WebAssembly Text Toolkit and Other Utilities
• Jain, 2021, WebAssembly with Rust and JavaScript An Introduction to wasm-bindgen
• Li and others, 2021, WiProg A WebAssembly-based Approach to Integrated IoT Programming
• Mannay, 2020, Artefacts, Third Objects, Sandboxing and Figurines in the Doll’s House
• Pailoor and others, 2020, Automated policy synthesis for system call sandboxing
• Aponte, 2020, Blazor Server vs. Blazor WebAssembly
• Himschoot, 2020, Conclusion Debugging Blazor WebAssembly
• Himschoot, 2020, Debugging Blazor WebAssembly
• Bock, 2020, Deconfounding and Sandboxing Patent Litigation with a Specialized Patent Trial Court
• Mendki, 2020, Evaluating Webassembly Enabled Serverless Approach for Edge Computing
• Raymond and Raj, 2020, Reversing and auditing of android malicious applications using sandboxing environment
• Karagiannis and others, 2020, Sandboxing the Cyberspace for Cybersecurity Education and Learning
• Mannay and Turney, 2020, Sandboxing a creative approach to qualitative research in education
• Perényi and Midtgaard, 2020, Stack-Driven Program Generation of WebAssembly
• Himschoot, 2020, Targeting both Blazor Server and Blazor WebAssembly
• Scheidl, 2020, Valent-Blocks Scalable High-Performance Compilation of WebAssembly Bytecode For Embedded Systems
• Jacobsson and Willén, 2020, Virtual Machine Execution for Wearables Based on WebAssembly
• Pinckney and others, 2020, Wasm/k delimited continuations for WebAssembly
• Wen and Weber, 2020, Wasmachine Bring the Edge up to Speed with A WebAssembly OS
• Zheng and others, 2020, WebAssembly WASM
• Besson and others, 2019, Compiling Sandboxes Formally Verified Software Fault Isolation
• Vécsi and others, 2019, Cross-platform Identity-based Cryptography using WebAssembly
• Iqbal and others, 2019, Digital Forensic Analysis of Industrial Control Systems Using Sandboxing A Case of WAMPAC Applications in the Power Systems
• Protzenko and others, 2019, Formally Verified Cryptographic Web Applications in WebAssembly
• Kalff, 2019, Labor Democracy in Digitalizing Industries Emancipating or “Sandboxing” Participation in Discourses on Technology and New Forms of Work?
• Staps and others, 2019, Lazy interworking of compiled and interpreted code for sandboxing and distributed systems
• Narain and Noubir, 2019, Mitigating Location Privacy Attacks on Mobile Devices using Dynamic App Sandboxing
• Wan and others, 2019, Practical and effective sandboxing for Linux containers
• Hassan and others, 2019, SandBoxer A Self-Contained Sensor Architecture for Sandboxing the Industrial Internet of Things
• Zhong and others, 2019, Sandboxing Controllers for Stochastic Cyber-Physical Systems
• Halvorsen and others, 2019, Sandboxing for Cross-Platform Applications of Robots
• Sammler and others, 2019, The high-level benefits of low-level sandboxing
• Watt and others, 2019, Weakening WebAssembly
• Bijlani and Ramachandran, 2018, A Lightweight and Fine-grained File System Sandboxing Framework
• Kumar and Bhim Bhan Singh, 2018, A Zero-Day Resistant Malware Detection Method for Securing Cloud Using SVM and Sandboxing Techniques
• Finney and Meerzaman, 2018, Chromatic WebAssembly-Based Cancer Genome Viewer
• Cafasso and Tarral, 2018, Designing flexible sandboxing solutions to adapt to new malware trends
• Manès and others, 2018, Domain Isolated Kernel A lightweight sandbox for untrusted kernel extensions
• Watt, 2018, Mechanising and verifying the WebAssembly specification
• Besson and others, 2018, Modular Software Fault Isolation as Abstract Interpretation
• Heil and others, 2018, ReWaMP Rapid Web Migration Prototyping Leveraging WebAssembly
• Rigger, 2018, Sandboxed execution of C and other unsafe languages on the Java virtual machine
• Witt and others, 2018, Sandboxing of biomedical applications in Linux containers based on system call evaluation
• Møller, 2018, Technical perspective WebAssembly a quiet revolution of the web
• Wang and others, 2018, Towards Android Application Protection via Kernel Extension
• Aweke and Austin, 2018, uSFI Ultra-lightweight software fault isolation for IoT-class devices
• Laurén and others, 2017, A Survey on Application Sandboxing Techniques
• 2017, Noisy label based discriminative least squares regression and its kernel extension for object identification
• Neves and others, 2017, Sandboxing Data Plane Programs for Fun and Profit
• 2017, Sandboxing. Un juego de negociación de recursos
• Dang and others, 2016, A novel least Cauchy error algorithm and its kernel extension
• 2016, A systematic analysis of the science of sandboxing
• Corral and others, 2016, An Android Kernel Extension to Save Energy Resources Without Impacting User Experience
• Mead and others, 2016, Defeating drone jamming with hardware sandboxing
• Afonso and others, 2016, Going Native Using a Large-Scale Analysis of Android Apps to Create a Practical Native-Code Sandboxing Policy
• Van Acker and Sabelfeld, 2016, JavaScript Sandboxing Isolating and Restricting Client-Side JavaScript
• Luo and others, 2016, Mashic compiler Mashup sandboxing based on inter-frame communication
• Corral and others, 2016, Preserving energy resources using an Android kernel extension
• Borate and K., 2016, Sandboxing in Linux From Smartphone to Cloud
• Adamov and Carlsson, 2015, A sandboxing method to protect cloud cyberspace
• Mehra and Pandey, 2015, Event triggered malware A new challenge to sandboxing
• Deng and others, 2015, ISboxing An Instruction Substitution Based Data Sandboxing for x86 Untrusted Libraries
• Helmy and others, 2015, Performance Evaluation of System Resources Utilization with Sandboxing Applications
• Jiang and others, 2015, Protection Tiers and Their Applications for Evaluating Untrusted Code on A Linux-Based Web Server
• Ghosh and others, 2015, Sandboxing and reasoning on malware infection trees
• Colon Osorio and others, 2015, Segmented sandboxing - A novel approach to Malware polymorphism detection

The mechanics the five literatures rest on

The five literatures above are the ones the article’s argument engages. They sit on a body of work about how a compiler actually moves and deletes things, and that work is a different literature from the technologies above it. The distinction matters here because Result 1 turns on a specific mechanical fact, being that the optimiser promotes stack allocations into registers, and no paper about verified compilation discusses that decision while a great many papers about register allocation do.

Code generation and optimisation itself account for 439 contemporary records.

• Abdulhalik and others, 2026, A Modular Graph Coloring Abstraction for Register Allocation in LLVM Design and Evaluation
• Tirichine and others, 2026, A Reinforcement Learning Environment for Automatic Code Optimization in the MLIR Compiler
• C Nair, 2026, AI Tools for Code Generation Transforming Modern Software Development
• Cui and others, 2026, An Efficient Clustered Register Allocation Algorithm for VLIW DSP Processors
• Zhao and others, 2026, AutoML-Pipeline A RAG-Enhanced Code Generation Framework With Pre-Validation for Cloud-Native Machine Learning Workflows
• Latif and others, 2026, Benchmarking Embedded C Code Generation Techniques for Safety-Critical Automotive Applications Aligned with MISRA C and ISO 26262
• Paleyes and others, 2026, Code Roulette How Prompt Variability Affects LLM Code Generation
• Khmyznikov, 2026, Comparative Analysis of MSVC and Clang/LLVM Compilation on Windows on Arm
• Dhiman and others, 2026, Compiler Performance Analysis for AI Workloads on RISC-V A Comprehensive Comparison of GCC and LLVM
• Reddy and others, 2026, Compiler-Assisted Instruction Fusion
• Yao and others, 2026, Compiler-based loop unrolling optimization for dual-SIMD extensions
• Kwon and others, 2026, Compiler-Runtime Co-operative Chain of Verification for LLM-Based Code Optimization
• Vukasović and others, 2026, Context-Aware Inlining Using Call-Stack Profiles for Fast and Smaller Binaries
• Milyutin and others, 2026, DEOBFUSCATION OF MALICIOUS SOFTWARE USING LLVM INTERMEDIATE REPRESENTATION
• Dondeti, 2026, Ede-Slm Execution-Driven Ensembles for Sub-1B Code Generation Models
• Chirag Yadav, 2026, Empirical Evaluation of AI-Assisted Code Generation on Full-Stack Web Development Performance
• Alladi and others, 2026, Enabling Automatic Compiler-Driven Vectorization of Transformers
• Li and others, 2026, From Threads to Tiles T2T, a Compiler for CUDA-to-NPU Translation via 2D Vectorization
• Zhang and others, 2026, Hexcute A Compiler Framework for Automating Layout Synthesis in GPU Programs
• Sengupta and others, 2026, HLS Register Allocation Attack for Compromising Hardware IP Designs using HLS-aided Trojan
• Lai and others, 2026, Interaction-aware multi-objective optimization method for LLVM compiler option sequences
• Fang and others, 2026, LLM-VeriOpt Verification-Guided Reinforcement Learning for LLM-Based Compiler Optimization
• Meng and others, 2026, Low-Compilation-Cost Register Allocation in LLVM-Based Binary Translation
• Xu and others, 2026, LPO Discovering Missed Peephole Optimizations with Large Language Models
• Peng and others, 2026, Multi-dimensional Cost-Driven LDSP Instruction Scheduling Optimization
• Su and others, 2026, Optimization and vectorization of an Mz-type optically pumped rubidium magnetometer
• Kim, 2026, Optimizing RAG-Assisted Code Generation for Cloud-Native ML Pipelines Through Dynamic Context Window Management
• Crespo and others, 2026, S2VEC Compiler-Driven Stream Specialization for Linearized Vectorization
• de Ferrière and others, 2026, SecSwift, a Compiler-Based Framework for Software Countermeasures in Cybersecurity
• Adnyana and Schwung, 2026, Standard Conformant Prompting SCP A Reproducible Framework for Compiler-Ready PLC Code Generation with Large Language Models From Post-Hoc Verification to Standard-Driven Code Synthesis in Industrial Automation
• Adve and Lattner, 2026, The LLVM Compiler Infrastructure
• Qian and others, 2026, Thinking Fast and Correct Automated Rewriting of Numerical Code through Compiler Augmentation
• Hong and others, 2026, Tiling-Aware Vectorization Framework for Perfect Loop Nests in MLIR
• Ko and Heo, 2026, TinyGen Portable and Compact Code Generation for Tiny Machine Learning
• Schwarz and others, 2026, TPDE A Fast Adaptable Compiler Back-End Framework
• Nicolosi and others, 2026, Type Deduction Analysis Reconstructing Transparent Pointer Types in LLVM-IR
• Zhu and Xie, 2025, A Domain-Specific Compiler for Embedded DSP Development Based on Component Code Generation Architecture and Correctness
• Xiao and others, 2025, A Graph-Based Learning Framework for Compiler Loop Auto-Vectorization
• Tulshihar Patil, 2025, A Mathematical Modeling Framework Opti-Blend for Integrated Code Analysis through Dead Code Elimination, Clone Detection, and Loop Optimization
• Kumar and others, 2025, Analyzing Dead Code Elimination Techniques for Green and Efficient Web Applications
• Ziyodov, 2025, Arithmetic Expression Compiler Using Python And LLVM
• Huang and others, 2025, Automatic Compiler Tuning for Inlining with Machine Learning
• Thakur and others, 2025, CLEVER A Curated Benchmark for Formally Verified Code Generation
• Mössenböck, 2025, Code Generation
• Chen and others, 2025, Code-as-Symbolic-Planner Foundation Model-Based Robot Planning via Symbolic Code Generation
• Hammer and others, 2025, Compiler-Like Code Generation for fUML Reducing Overhead in Executable UML
• Huang and others, 2025, CompressRA+ Enhanced Register Allocation for Compressed ISAs
• Chen and others, 2025, DCE-LLM Dead Code Elimination with Large Language Models
• Pan and others, 2025, E-code Mastering efficient code generation through pretrained models and expert encoder group
• Kwan and Onen, 2025, Enhancing Common Subexpression Elimination Algorithms
• Cai and others, 2025, Faster Chaitin-like Register Allocation via Grammatical Decompositions of Control-Flow Graphs
• Fan and others, 2025, FGit Fault-Guided Fine-Tuning for Code Generation
• Cho and others, 2025, From Timed Automata to Go Formally Verified Code Generation and Runtime Monitoring for Cyber-Physical Systems
• Chen and others, 2025, GoDetect Precise Detection of Go Smart Contract Vulnerabilities Based on Static Single Assignment SSA
• Peng and others, 2025, GoFree Reducing Garbage Collection via Compiler-Inserted Freeing
• Leite and others, 2025, Implementing new RISC-V Instructions with the LLVM Compiler Infrastructure
• Han and others, 2025, Instruction Scheduling Optimization Based on the Triton Compiler
• Han and others, 2025, JOVS Joint Optimization of Vectorization and Scheduling for DNN on AI DSPs
• Chen and others, 2025, Key Operator Vectorization for LeNet and ResNet Based on Buddy Compiler
• Wasekar and others, 2025, Lacuna-Based JavaScript Code Visualization and Dead Code Optimization A Cross-Platform Performance Evaluation
• Bataev, 2025, LLVM Loop Vectorizer
• Bataev, 2025, LLVM SLP Vectorizer
• Zhu and others, 2025, LLVMTuner Predictive Compiler Optimization for LLVM IR Across Heterogeneous Platforms
• Han and others, 2025, Loop Splitting Optimization Via Semi-Invariance Analysis in Static Single Assignment Form
• Liu and others, 2025, Loop Vectorization Optimization Technique for System Calls
• Xing and others, 2025, Multi-level parallelism optimization for two-dimensional convolution vectorization method on multi-core vector accelerator
• Manimegalai and Riyaayini, 2025, Optimizing Compiler Efficiency A Comparative Study of Parallelization Frameworks for Register Allocation
• Guan and others, 2025, Peephole Optimization Strategies for Intermediate Code in the Compilation Process
• Malladi and Hariharan, 2025, Performance Analysis of Compiler Code Generation for HPC and AI Kernels on RISC-V
• Zhao and others, 2025, PolyMorphous An MLIR-Based Polyhedral Compiler with Loop Transformation Primitives
• Fan and others, 2025, Postiz Extending Post-increment Addressing for Loop Optimization and Code Size Reduction
• Dougherty and Mehta, 2025, Proving the Coding Interview A Benchmark for Formally Verified Code Generation
• Xia and Cheng, 2025, Research on Optimization of Large Model Code Generation Based on Improved RAG in Embedded Environments
• Ying, 2025, Research on Ship Speed Prediction Based on Angle Feature Vectorization and Bayesian Optimization
• Ren and others, 2025, Revisiting Optimization-Resilience Claims in Binary Diffing Tools Insights from LLVM Peephole Optimization Analysis
• Bataev, 2025, RISC-V RVV Specific LLVM-Based Optimizations
• Raste and others, 2025, SLIM A Simplified LLVM IR Abstraction for Compiler Design Courses
• Li and others, 2025, Stack Filtering Elevating Precision and Efficiency in Rust Pointer Analysis
• Zurstraβen and others, 2025, Static Global Register Allocation for Dynamic Binary Translators
• Patel and others, 2025, SySTeC A Symmetric Sparse Tensor Compiler
• Muravyev, 2025, THE A VULNERABILITIES OF GCC AND LLVM TO OPTIMIZATION PIPELINE ATTACKS
• Lücke and others, 2025, The MLIR Transform Dialect
• Pan and others, 2025, Towards Efficient Compiler Auto-tuning Leveraging Synergistic Search Spaces
• Ye and others, 2025, Vectorization and Parallel Computing Optimization for Circular SAR Back Projection Algorithm
• Naser Moghaddasi and others, 2025, Vectron A Dynamic Programming Auto-vectorization Framework
• Jin and others, 2025, VeriLocc End-to-End Cross-Architecture Register Allocation via LLM
• Menezes and others, 2025, VO-GCSE Verification Optimization through Global Common Subexpression Elimination
• Kırmemiş and others, 2025, Weaver A Retargetable Compiler Framework for FPQA Quantum Architectures
• Cross, 2025, wrenfold Symbolic code generation for robotics
• Sajjadinasab and others, 2024, A Graph-Based Algorithm for Optimizing GCC Compiler Flag Settings
• Tulshihar Patil, 2024, A Novel Approach to Eliminate the Dead Code and Change the Looping Structure for Optimizing the Code
• Shaikhha and others, 2024, A Tensor Algebra Compiler for Sparse Differentiation
• Hu, 2024, Advancements and Prospects in Machine Learning-Driven Code Generation and Completion
• Robin and Khan, 2024, An open-source P416 compiler backend for reconfigurable match-action table switches Making networking innovation accessible
• Tu and others, 2024, Beyond a Joke Dead Code Elimination Can Delete Live Code
• Terci and others, 2024, BitEA BitVertex Evolutionary Algorithm to Enhance Performance for Register Allocation
• Baek and Lee, 2024, CaLLi OCaml library for static analysis of LLVM bitcode
• Wazlawick, 2024, Code generation
• Bilgili and Yurdakul, 2024, Common Subexpression-Based Compression and Multiplication of Sparse Constant Matrices
• Engelke and Schwarz, 2024, Compile-Time Analysis of Compiler Frameworks for Query Compilation
• Geeson and Smith, 2024, Compiler Testing with Relaxed Memory Models
• Gautam and others, 2024, Design and Implementation of a Minimalist Programming Language Stab using Flex, Bison and LLVM
• Xiao, 2024, Design of Chinese Programming Language Compiler Based on LLVM Framework
• Balasubramanian and others, 2024, Designing RISC-V Instruction Set Extensions for Artificial Neural Networks An LLVM Compiler-Driven Perspective
• Han and others, 2024, Enabling Fine-Grained Incremental Builds by Making Compiler Stateful
• Stuckmann and others, 2024, Energy-Aware Register Allocation for VLIW Processors
• S and C.R., 2024, Enhancing GCC Compiler Optimization Through Natural Language Processing-Driven Automation
• Jesus and Weiland, 2024, Evaluating and optimising compiler code generation for NVIDIA Grace
• Tiotto and others, 2024, Experiences Building an MLIR-Based SYCL Compiler
• Drescher and Engelke, 2024, Fast Template-Based Code Generation for MLIR
• Wang and others, 2024, Formally Verified C Code Generation from Hybrid Communicating Sequential Processes
• Chichereau and others, 2024, Fully Integrated Quantum Method for Classical Register Allocation in LLVM
• Yang and others, 2024, Fully Verified Instruction Scheduling
• Schirmer and others, 2024, FUSIONIZE++ Improving Serverless Application Performance Using Dynamic Task Inlining and Infrastructure Optimization
• Hollenbeck and O’Boyle, 2024, Hot Call-Chain Inlining for the Glasgow Haskell Compiler
• Mukherjee and Regehr, 2024, Hydra Generalizing Peephole Optimizations with Program Synthesis
• Shobaki and others, 2024, Instruction Scheduling for the GPU on the GPU
• Silva and others, 2024, Interference Graph Dataset for Machine Learning-Based Register Allocation
• Mogensen, 2024, Intermediate-Code Generation
• Ruhela, 2024, Investigating the Performance of LLVM-Based Intel Fortran Compiler ifx
• Zeng and others, 2024, Joint speaker encoder and neural back-end model for fully end-to-end automatic speaker verification with multiple enrollment utterances
• He and others, 2024, Leveraging MLIR for Loop Vectorization and GPU Porting of FFT Libraries
• Nejjar and others, 2024, LLMs for science Usage for code generation and data analysis
• Wang and Jiao, 2024, LLVM back-end instruction scheduling optimization based on improved genetic algorithm
• 2024, LLVM-HPC 2024 The Tenth Annual Workshop on the LLVM Compiler Infrastructure in HPC
• Shi and others, 2024, Machine Learning-Driven GCC Loop Unrolling Optimization Compiler Performance Enhancement Strategy Based on XGBoost
• Mogensen, 2024, Machine-Code Generation
• Sha and others, 2024, OpTrans enhancing binary code similarity detection with function inlining re-optimization
• Clark and Thapliyal, 2024, Peephole Optimization for Quantum Approximate Synthesis
• Xie and others, 2024, Performance Improvements via Peephole Optimization in Dynamic Binary Translation
• Esraa, 2024, Predicting Loop Vectorization through Machine Learning Algorithms
• Guan and others, 2024, PresCount Effective Register Allocation for Bank Conflict Reduction
• Mogensen, 2024, Register Allocation
• Li and others, 2024, Research on uncovering parallelism in perfect loop nests for GCC compiler
• Seeker and others, 2024, Revealing Compiler Heuristics Through Automated Discovery and Optimization
• Sengupta and others, 2024, Robust Watermarking of Loop Unrolled Convolution Layer IP Design for CNN using 4-variable Encoded Register Allocation
• Xie and others, 2024, SORA Rapid Software Pipelining Optimization after Register Allocation for Vector-DSPs
• Taft, 2024, Sound and precise static analysis using a generalization of static single assignment and value numbering
• Arch and others, 2024, The Key to Effective UDF Optimization Before Inlining, First Perform Outlining
• 2024, The Loop Invariant for Lower Bounds
• Egunov and Kravets, 2024, The New Method for Automatic Vectorization Efficiency Increasing
• Tulshihar Patil, 2024, The Opticode A User-Centric Tool for Enhancing Software Efficiency and Minimizing Errors Through Dead Code Elimination and Loop Invariant Code Motion Techniques
• Liegeois and others, 2024, Towards Reverse Mode Automatic Differentiation of Kokkos-Based Code Using the LLVM Compiler Infrastructure
• Maroun and others, 2024, Two-Step Register Allocation for Implementing Single-Path Code
• Pasha, 2024, Vectorization and Runtime Improvements
• Titzer, 2024, Whose Baseline Compiler is it Anyway?
• Amin and others, 2023, A Comparative Study of Register Allocation Algorithms
• Liu and others, 2023, A Complement Graph Based Heuristic Algorithm for Embedded Register Allocation
• Terci, 2023, A Learning-Based Coloring Algorithm for Register Allocation Problem
• Panigrahi and Karfa, 2023, An Investigation into the Security of Register Allocation with Spilling and Splitting
• Engel and others, 2023, BIRD A Binary Intermediate Representation for Formally Verified Decompilation of X86-64 Binaries
• Han and others, 2023, Cooperative compilation optimization of register allocation and thread management for AMDGPU
• Chichereau and others, 2023, Experimenting with Hybrid Quantum Optimization in HPC Software Stack for CPU Register Allocation
• Kim and Kong, 2023, Front-end AI vs. Back-end AI new framework for securing truth in communication during the generative AI era
• Lee and Micheli, 2023, Heuristic Logic Resynthesis Algorithms at the Core of Peephole Optimization
• Ghiglio and others, 2023, Improving performance of SYCL applications on CPU architectures using LLVM-directed compilation flow
• Cooper and Torczon, 2023, Instruction Scheduling
• Cooper and Torczon, 2023, Instruction Selection
• Malavolta and others, 2023, JavaScript Dead Code Identification, Elimination, and Empirical Assessment
• Thangamani and others, 2023, Lifting Code Generation of Cardiac Physiology Simulation to Novel Compiler Technology
• Bao and Fu, 2023, Line Drawing Vectorization via Coarse-to-Fine Curve Network Optimization
• Valle, 2023, LLVM CFI Support for Rust
• Barai and others, 2023, LLVM Static Analysis for Program Characterization and Memory Reuse Profile Estimation
• Sadasue and Isshiki, 2023, LLVM-C2RTL C/C++ Based System Level RTL Design Framework Using LLVM Compiler Infrastructure
• Herklotz and others, 2023, Mechanised Semantics for Gated Static Single Assignment
• Logunov and Kharin, 2023, Methodology for Developing a High-speed Compiler Based on the Modified Loop Fusion Optimization Method Models and Tools for its Implementation
• Kandiah and others, 2023, Parsimony Enabling SIMD/Vector Programming in Standard Compiler Flows
• Shin and others, 2023, PIMFlow Compiler and Runtime Support for CNN Models on Processing-in-Memory DRAM
• Wu, 2023, PyTorch 2.0 The Journey to Bringing Compiler Technologies to the Core of PyTorch Keynote
• Xiao and others, 2023, Read-Write Dependency Aware Register Allocation
• Cooper and Torczon, 2023, Register Allocation
• Fried and others, 2023, Register Allocation for Compressed ISAs in LLVM
• VenkataKeerthy and others, 2023, RL4ReAl Reinforcement Learning for Register Allocation
• Bonnici and Camilleri, 2023, Simplification and Vectorization of Sketched Drawings
• Tant and others, 2023, Software Compilation Using FPGA Hardware Register Allocation
• Valle, 2023, Suporte a LLVM CFI para Rust
• Gupta and others, 2023, Techniques and Trade-Offs in Function Inlining Optimization
• Gartung, 2023, Vectorization of CMSSW offline software
• Dardinier and others, 2023, Verification-Preserving Inlining in Automatic Separation Logic Verifiers
• Liu and Wang, 2023, Verified Transformation of Continuation-Passing Style into Static Single Assignment Form
• Rivera and others, 2022, A Compiler for Sound Floating-Point Computations using Affine Arithmetic
• Olabi and others, 2022, A Compiler Framework for Optimizing Dynamic Parallelism on GPUs
• Coglio, 2022, A Proof-Generating C Code Generator for ACL2 Based on a Shallow Embedding of C in ACL2
• Hou and others, 2022, An Evaluation of Performance-Oriented Instruction Block for Block-Granularity Instruction Scheduling
• Yan and others, 2022, An LLVM-based open-source compiler for NVIDIA GPUs
• Guaitero and others, 2022, Automatic Asynchronous Execution of Synchronously Offloaded OpenMP Target Regions
• Akanbi and others, 2022, Code Generation Techniques in Compiler Design Conceptual and Structural Review
• Cummins and others, 2022, CompilerGym Robust, Performant Compiler Optimization Environments for AI Research
• Jiang and others, 2022, CTOS Compiler Testing for Optimization Sequences of LLVM
• Tian and others, 2022, Direct GPU Compilation and Execution for Host Applications with OpenMP Parallelism
• Theodoridis and others, 2022, Finding missed optimizations through the lens of dead code elimination
• Shobaki and others, 2022, Graph transformations for register-pressure-aware instruction scheduling
• Brahmakshatriya and Amarasinghe, 2022, GraphIt to CUDA Compiler in 2021 LOC A Case for High-Performance DSL Implementation via Staging with BuilDSL
• Lee and others, 2022, HECATE Performance-Aware Scale Optimization for Homomorphic Encryption Compiler
• Shin and Sung, 2022, Hybrid Register Allocation with Spill Cost and Pattern Guided Optimization
• Poletanovic and others, 2022, Implementation of Machine Outliner for nanoMIPS in the LLVM Compiler Infrastructure
• Mosaner and others, 2022, Improving Vectorization Heuristics in a Dynamic Compiler with Machine Learning Models
• Hollenbeck and others, 2022, Investigating magic numbers improving the inlining heuristic in the Glasgow Haskell Compiler
• Zhou and others, 2022, LocSeq Automated Localization for Compiler Optimization Sequence Bugs of LLVM
• Katel and others, 2022, MLIR-based code generation for GPU tensor cores
• Ben-Asher and others, 2022, Mutual Inlining An Inlining Algorithm to Reduce the Executable Size
• Muts and Falk, 2022, Predicting Worst-Case Execution Times During Multi-criterial Function Inlining
• Ittah and others, 2022, QIRO A Static Single Assignment-based Quantum Program Representation for Optimization
• Shobaki and others, 2022, Register-Pressure-Aware Instruction Scheduling Using Ant Colony Optimization
• Jain and others, 2022, Reinforcement Learning assisted Loop Distribution for Locality and Vectorization
• Shahzad and others, 2022, Reinforcement Learning Strategies for Compiler Optimization in High level Synthesis
• Hu and others, 2022, Research on global register allocation for code containing array-unit dual-usage register names
• Panigrahi and others, 2022, Secure Register Allocation for Trusted Code Generation
• Kim and others, 2022, Solving PBQP-Based Register Allocation using Deep Reinforcement Learning
• Vishwanathan and others, 2022, Sound, Precise, and Fast Abstract Interpretation with Tristate Numbers
• Sommer and others, 2022, SPNC An Open-Source MLIR-Based Compiler for Fast Sum-Product Network Inference on CPUs and GPUs
• Park and others, 2022, SRTuner Effective Compiler Optimization Customization by Exposing Synergistic Relations
• Huang and others, 2022, Structure Peeling Based on Link Time Optimization in the GCC compiler
• Johnsen and others, 2022, Temporal Vectorization
• Xiao and others, 2022, Timing Error Aware Register Allocation in TS
• Fanti and others, 2022, Toward Register Spilling Security Using LLVM and ARM Pointer Authentication
• Tahvili and Hatvani, 2022, Transformation, vectorization, and optimization
• Mzid and others, 2022, Use of Compiler Intermediate Representation for Reverse Engineering A Case Study for GCC Compiler and UML Activity Diagram
• Tian and others, 2021, A High Performance Sparse Tensor Algebra Compiler in MLIR
• Rivera and others, 2021, An Interval Compiler for Sound Floating-Point Computations
• Sarkar and others, 2021, Array SSA Form
• Kechar and others, 2021, Bringing Common Subexpression Problem from the Dark to Light Towards Large-Scale Workload Optimizations
• 2021, Code Generation and Optimization
• Damani and Sarkar, 2021, Common Subexpression Convergence A New Code Optimization for SIMT Processors
• Jamieson and Brown, 2021, Compact native code generation for dynamic languages on micro-core architectures
• Bruno and others, 2021, Compiler-assisted object inlining with value fields
• Skvortsov and others, 2021, Developing an LLVM-based compiler for stack based TF16 processor architecture
• Wu and others, 2021, Effective Register Allocation for Configurable VLIW Crypto-Processor
• Khaldi and others, 2021, Extending LLVM IR for DPC++ Matrix Support A Case Study with Intel ® Advanced Matrix Extensions Intel ® AMX
• Clement and Vetter, 2021, Flacc Towards OpenACC support for Fortran in the LLVM Ecosystem
• Mantione and Chow, 2021, Hashed SSA Form HSSA
• Wang, 2021, Helper function inlining in dynamic binary translation
• Demmler and others, 2021, Improved Circuit Compilation for Hybrid MPC via Compiler Intermediate Representation
• Damásio and others, 2021, Inlining for Code Size Reduction
• Kasampalis and others, 2021, Language-parametric compiler validation with application to LLVM
• Chen and others, 2021, LCSSA optimization for vectorization recognition rate improvement
• Lattner and others, 2021, MLIR Scaling Compiler Infrastructure for Domain Specific Computation
• Gao and Xu, 2021, Open-Loop Optimization Schemes
• Bora and others, 2021, OpenMP aware MHP Analysis for Improved Static Data-Race Detection
• Azkarate and others, 2021, Petri Net-Based Semi-Compiled Code Generation for Programmable Logic Controllers
• de Ferrière, 2021, Psi-SSA Form
• Tichadou and Rastello, 2021, Register Allocation
• Liu and others, 2021, Relaxed Peephole Optimization A Novel Compiler Optimization for Quantum Circuits
• Jost and others, 2021, Seamless Compiler Integration of Variable Precision Floating-Point Arithmetic
• Monniaux and Six, 2021, Simple, light, yet formally verified, global common subexpression elimination and loop-invariant code motion
• Dupont de Dinechin, 2021, SSA Form and Code Generation
• Kim and others, 2021, Thread-Aware Area-Efficient High-Level Synthesis Compiler for Embedded Devices
• Zhao and Liu, 2021, Thread-Level Speculation Execution Model Based on LLVM Compiler
• Leidel and others, 2021, Toward an Automated Hardware Pipelining LLVM Pass Infrastructure
• Koehler and Steuwer, 2021, Towards a Domain-Extensible Compiler Optimizing an Image Processing Pipeline on Mobile CPUs
• Xie and others, 2021, Towards Understanding Tool-chain Bugs in the LLVM Compiler Infrastructure
• Loveless and others, 2020, A performance-optimizing compiler for cyber-physical digital microfluidic biochips
• Roy and Chandra, 2020, A Triangular Common Subexpression Elimination Algorithm With Reduced Logic Operators in FIR Filter
• Litteken and others, 2020, An updated LLVM-based quantum research compiler with further OpenQASM support
• Kruse and others, 2020, Autotuning Search Space for Loop Transformations
• Das and others, 2020, Deep Learning-based Approximate Graph-Coloring Algorithm for Register Allocation
• Mishra and others, 2020, Extending the LLVM/Clang Framework for OpenMP Metadirective Support
• Catalao and de Sousa, 2020, IEC 61131-3 Front-End for the LLVM Compiler Family
• Rigon and others, 2020, Inferring types and effects via static single assignment
• Garzella and others, 2020, Leveraging Compiler Intermediate Representation for Multi- and Cross-Language Verification
• Masud and Ciccozzi, 2020, More precise construction of static single assignment programs using reaching definitions
• Muts and Falk, 2020, Multi-Criteria Function Inlining for Hard Real-Time Systems
• Sopasakis and others, 2020, OpEn Code Generation for Embedded Nonconvex Optimization
• 2020, Performance Analysis of Optimization of Convolution Operation In Neural Network Using Loop Optimization Technique
• Liacha and others, 2020, Radix-2 r recoding with common subexpression elimination for multiple constant multiplication
• Engelke and Schulz, 2020, Robust Practical Binary Optimization at Run-time using LLVM
• Lazcano and others, 2020, Runtime multi-versioning and specialization inside a memoized speculative loop optimizer
• Mammadli and others, 2020, Static Neural Compiler Optimization via Deep Reinforcement Learning
• Reif and others, 2020, TACAI an intermediate representation based on abstract interpretation
• Taneja and others, 2020, Testing static analyses for precision and soundness
• Courant and others, 2020, The Correctness of a Code Generator for a Functional Language
• Dakkak and others, 2020, The design and implementation of the wolfram language compiler
• Tatiana, 2020, Vectorization and Optimization of User Behavior Data in E Learning Systems
• Rocha and others, 2020, Vectorization-aware loop unrolling with seed forwarding
• Sharif and others, 2019, A Wizard-based Approach for Secure Code Generation of Single Sign-On and Access Delegation Solutions for Mobile Native Apps
• Lee and others, 2019, AliveInLean A Verified LLVM Peephole Optimization Verifier
• Zhang and others, 2019, Analysis of Automatic Code Generation Tools based on Machine Learning
• Wei and others, 2019, Characterizations of multiobjective robustness on vectorization counterparts
• Hariri and others, 2019, Comparing Mutation Testing at the Levels of Source Code and Compiler Intermediate Representation
• KIRCHHOFF and others, 2019, Compiler Optimization on Instruction Scheduling for a Specialized Real-Time Floating Point Soft-Core Processor
• Shobaki and others, 2019, Exploring an Alternative Cost Function for Combinatorial Register-Pressure-Aware Instruction Scheduling
• Kruppe and others, 2019, Extending LLVM for Lightweight SPMD Vectorization Using SIMD and Vector Instructions Easily from Any Language
• Manuprasad and others, 2019, Inexact Addition and Subtraction for the Reconfigurable FIR Filter Implementation using CSD based Common Subexpression Elimination
• Fornaia and others, 2019, JSCAN Designing an Easy to use LLVM-Based Static Analysis Framework
• Castro-Lopez and Vega-Lopez, 2019, Multi-target Compiler for the Deployment of Machine Learning Models
• Akbulut and others, 2019, Native Code Generation as a Service
• Li and others, 2019, Structure optimization method based on automatic vectorization
• Рыбаков and Шумилин, 2019, Study of the vectorization efficiency of loop nests with an irregular number of iterations
• Lozano and Schulte, 2019, Survey on Combinatorial Register Allocation and Instruction Scheduling
• Baghdadi and others, 2019, Tiramisu A Polyhedral Compiler for Expressing Fast and Portable Code
• Curtis and others, 2018, A compiler for cyber-physical digital microfluidic biochips
• Tseng and Chen, 2018, A loop transformation technique for timing speculative architecture
• Gong and others, 2018, An empirical study of the effect of source-level loop transformations on compiler stability
• Obbink and others, 2018, An extensible approach for taming the challenges of JavaScript dead code elimination
• Ye and others, 2018, An Optimized Design for Compact Masked AES S-Box Based on Composite Field and Common Subexpression Elimination Algorithm
• Kataev, 2018, Application of the LLVM Compiler Infrastructure to the Program Analysis in SAPFOR
• Denny and others, 2018, CLACC Translating OpenACC to OpenMP in Clang
• Chapa, 2018, Code Obfuscation Study Using Obfuscator-LLVM
• Kumar, 2018, COMPARISON OF INSTRUCTION SCHEDULING AND REGISTER ALLOCATION FOR MIPS AND HPL-PD ARCHITECTURE FOR EXPLOITATION OF INSTRUCTION LEVEL PARALLELISM
• Jiang and Agrawal, 2018, Conflict-free vectorization of associative irregular applications with recent SIMD architectural advances
• Kang and others, 2018, Crellvm verified credible compilation for LLVM
• Romano, 2018, Dead Code
• Leopoldseder and others, 2018, Dominance-based duplication simulation DBDS code duplication to enable compiler optimizations
• Ming Chang and others, 2018, Efficient Compiler Code Generation for Deep Learning Snowflake Co-Processor
• Thier and others, 2018, Fast and flexible instruction selection with constraints
• Leopoldseder and others, 2018, Fast-path loop unrolling of non-counted loops to enable subsequent compiler optimizations
• Masten and others, 2018, Function/Kernel Vectorization via Loop Vectorizer
• Nowatzki and others, 2018, Hybrid optimization/heuristic instruction scheduling for programmable accelerator codesign
• Kananizadeh and Kononenko, 2018, Improving on Linear Scan Register Allocation
• Petrogalli and Walker, 2018, LLVM and the Automatic Vectorization of Loops Invoking Math Routines -FSIMDMATH
• Porpodas and others, 2018, Look-ahead SLP auto-vectorization in the presence of commutative operations
• Jinyang and others, 2018, Loop-nest Auto-vectorization Method Based on Benefit Analysis
• Sui and others, 2018, Loop-Oriented Pointer Analysis for Automatic SIMD Vectorization
• Nezzari and Bridges, 2018, Modelling processor reliability using LLVM compiler fault injection
• Susungi, 2018, On the semantics of loop transformation languages
• Balogh and others, 2018, OP2-Clang A Source-to-Source Translator Using Clang/LLVM LibTooling
• Bao-Cang, 2018, Open-loop optimization and closed-loop optimization in synthesis approaches
• Ozen and others, 2018, OpenMP GPU Offload in Flang and LLVM
• Dangeti and others, 2018, P4LLVM An LLVM Based P4 Compiler
• Eisl and others, 2018, Parallel trace register allocation
• Truby and others, 2018, Pointers Inside Lambda Closure Objects in OpenMP Target Offload Regions
• Lopes and others, 2018, Practical verification of peephole optimizations with Alive
• Chen and others, 2018, Register allocation for Intel processor graphics
• Liu and others, 2018, Research of Register Pressure Aware Loop Unrolling Optimizations for Compiler
• Dmitry S. and others, 2018, Static Analysis Technique for Searching Natural Semantic Defects of Program Objects and Software Implementation of This Approach Based on the LLVM Compiler Infrastructure and the Clang Frontend
• Yang and others, 2018, Support OpenCL 2.0 Compiler on LLVM for PTX Simulators
• Kruse and Finkel, 2018, User-Directed Loop-Transformations in Clang
• Montesinos Victoriano and García José M., 2018, Vectorization Strategies for Ant Colony Optimization on Intel Architectures
• 2018, Vectorization The Rise of Parallelism
• Shigenobu and others, 2017, A Translation Method of ARM Machine Code to LLVM-IR for Binary Code Parallelization and Optimization
• Wroblewski and others, 2017, Accelerating Spark Datasets by Inlining Deserialization
• Menendez and Nagarakatte, 2017, Alive-Infer data-driven precondition inference for peephole optimizations in LLVM
• Tschüter and others, 2017, An LLVM Instrumentation Plug-in for Score-P
• Thethi and Kumar, 2017, Area and power efficient register allocation technique for the implementation of PCA
• Su and others, 2017, Automatic generation of fast BLAS3-GEMM A portable compiler approach
• Mishra and others, 2017, Benchmarking and Evaluating Unified Memory for OpenMP GPU Offloading
• Watson, 2017, Code Generation
• Horváth and others, 2017, Code Generation in Serializers and Comparators of Apache Flink
• Lambert and Saunders, 2017, Compiler auto-vectorization of matrix multiplication modulo small primes
• Reis and others, 2017, Compiler Techniques for Efficient MATLAB to OpenCL Code Generation
• Basu and others, 2017, Compiler-based code generation and autotuning for geometric multigrid on GPU-accelerated supercomputers
• Pham and others, 2017, Complete Code Generation from UML State Machine
• Suda, 2017, Embedded-DSL-Like Code Generation and Optimization of Bayesian Estimation Routines with User-Defined Source-to-Source Code Transformation Framework Xevolver
• 2017, Implementing Data Flow Analysis in GCC
• Bercea and others, 2017, Implementing implicit OpenMP data sharing on GPUs
• Schmidt-Schauß and Sabel, 2017, Improvements in a call-by-need functional core language Common subexpression elimination and resource preserving translations
• Sathyanathan and others, 2017, Incremental whole program optimization and compilation
• Mogensen, 2017, Intermediate-Code Generation
• Li and others, 2017, Investigation on the Optimization for Storage Space in Register-Spilling
• Tian and others, 2017, LLVM Compiler Implementation for Explicit Parallelization and SIMD Vectorization
• Mogensen, 2017, Machine-Code Generation
• Yang and others, 2017, OpenCL 2.0 Compiler Adaptation on LLVM for PTX Simulators
• Seyfari and others, 2017, PVL Parallelization and Vectorization of Affine Perfectly Nested-Loops Considering Data Locality on Short-Vector Multicore Processors using Intrinsic Vectorization
• Lee and others, 2017, Region-based dual bank register allocation for reduced instruction encoding Architectures
• Mogensen, 2017, Register Allocation
• 2017, Single Static Assignment Form as Intermediate Representation
• Cui and others, 2017, Study on Android Native Layer Code Protection Based on Improved O-LLVM
• Carvalho and others, 2017, The Register Allocation and Instruction Scheduling Challenge
• Eisl and others, 2017, Trace Register Allocation Policies
• Watkinson and others, 2017, Using Data Dependence Analysis and Loop Transformations to Teach Vectorization
• Levesque and Vose, 2017, Vectorization
• 2017, Vectorization and Its Consequences
• Zinterhof, 2017, Vectorization of Cellular Automaton-Based Labeling of 3-D Binary Lattices
• Takizawa and others, 2017, Vectorization-Aware Loop Optimization with User-Defined Code Transformations
• Spampinato and Püschel, 2016, A basic linear algebra compiler for structured matrices
• Ding and others, 2016, A New Paradigm of Common Subexpression Elimination by Unification of Addition and Subtraction
• Karer and Soni, 2016, Accomplish common subexpression elimination in Eclipse Compiler
• Menendez and others, 2016, Alive-FP Automated Verification of Floating Point Based Peephole Optimizations in LLVM
• Jünger and Mallach, 2016, An integer programming approach to optimal basic block instruction scheduling for single-issue processors
• Kumar and others, 2016, Assisting Static Compiler Vectorization with a Speculative Dynamic Vectorizer in an HW/SW Codesigned Environment
• Jelinek and Zalud, 2016, Augmented Postprocessing of the FTLS Vectorization Algorithm - Approaching to the Globally Optimal Vectorization of the Sorted Point Clouds
• Rodriguez-Cancio and others, 2016, Automatic microbenchmark generation to prevent dead code elimination and constant folding
• Sikka and Kaur, 2016, Competent Dependence Graph Acclimatize as Intermediate Representation to Effectuate the Best Slicing Technique for Object Oriented Programs
• Tejaswini Deshmukh and others, 2016, Design of Common Subexpression Elimination Algorithm for Cyclotomic Fast Fourier Transform Over GF 23
• Florea and Gellert, 2016, E-learning approach of the graph coloring problem applied to register allocation in embedded systems
• Yang and others, 2016, Effective Clipart Image Vectorization through Direct Optimization of Bezigons
• Liu and Jiang, 2016, Efficient design of FIR filters using common subexpression elimination
• D’Elia and Demetrescu, 2016, Flexible on-stack replacement in LLVM
• Wu and others, 2016, gpucc an open-source GPGPU compiler
• Tian and others, 2016, LLVM Framework and IR Extensions for Parallelization, SIMD Vectorization and Offloading
• Sui and others, 2016, Loop-oriented array- and field-sensitive pointer analysis for automatic SIMD vectorization
• Namjoshi and Singhania, 2016, Loopy Programmable and Formally Verified Loop Transformations
• Bastoul, 2016, Mapping deviation a technique to adapt or to guard loop transformation intuitions for legality
• Jisha and Sheena, 2016, Modified GCC Compiler Pass for Thread- Level Speculation by Modifying the Window Size using Openmp
• Antao and others, 2016, Offloading Support for OpenMP in Clang and LLVM
• Dong and others, 2016, Outer-Loop Auto-Vectorization for SIMD Architectures Based on Open64 Compiler
• Zhang and others, 2016, Predicting HPC parallel program performance based on LLVM compiler
• Saito and others, 2016, Reducing the Functionality Gap Between Auto-Vectorization and Explicit Vectorization
• Lozano and others, 2016, Register allocation and instruction scheduling in Unison
• Domagała and others, 2016, Register allocation and promotion through combined instruction scheduling and loop unrolling
• Burroughs, 2016, Register allocation and spilling using the expected distance heuristic
• Rigger and others, 2016, Sulong - execution of LLVM-based languages on the JVM
• Sui and Xue, 2016, SVF interprocedural static value-flow analysis in LLVM
• Menendez and Nagarakatte, 2016, Termination-checking for LLVM peephole optimizations
• Moss and others, 2016, The ARES High-Level Intermediate Representation
• Sun and others, 2016, Toward understanding compiler bugs in GCC and LLVM
• Khaldi and Chapman, 2016, Towards Automatic HBM Allocation Using LLVM A Case Study with Knights Landing
• Dutta and others, 2016, Validation of Loop Parallelization and Loop Vectorization Transformations
• Jeffers and others, 2016, Vectorization
• Jeffers and others, 2016, Vectorization advisor
• Gautam and others, 2016, Vectorization and Optimization of Fog Removal Algorithm
• Kanada, 2016, Vectorization of multiple-precision arithmetic program and 201,326,000 decimal digits of pi calculation 1988
• Jeffers and others, 2016, Vectorization with AVX-512 intrinsics
• Jeffers and others, 2016, Vectorization with SDLT
• Buchwald and others, 2016, Verified construction of static single assignment form
• Alvanos and Trancoso, 2016, Video SIMDBench Benchmarking the Compiler Vectorization for Multimedia Applications
• Štill and others, 2016, Weak Memory Models as LLVM-to-LLVM Transformations
• Zhang and others, 2015, A low-delay common subexpression elimination algorithm for constant matrix multiplications over GF 2 m
• Kumar and others, 2015, An Improved Reconfigurable Finite Impulse Response Filter Using Common Subexpression Elimination Algorithm for Cognitive Radio
• Anderson and others, 2015, Automatic Vectorization of Interleaved Data Revisited
• Nightingale and others, 2015, Automatically Improving SAT Encoding of Constraint Problems Through Common Subexpression Elimination in Savile Row
• Inoue and Kaneko, 2015, Bitwidth-aware register allocation and binding for clock period minimization
• Krause, 2015, Bytewise Register Allocation
• Bin and others, 2015, Code Generation for Abstract Data Types Based on Program Analysis
• Azarderakhsh and others, 2015, Common Subexpression Algorithms for Space-Complexity Reduction of Gaussian Normal Basis Multiplication
• Karer and Soni, 2015, Dead code elimination technique in eclipse compiler for Java
• Vardanyan and others, 2015, Dynamic compilation of JavaScript programs to the statically typed LLVM intermediate representation
• Xu and Gregg, 2015, Efficient Exploitation of Hyper Loop Parallelism in Vectorization
• Xie and others, 2015, Enabling coordinated register allocation and thread-level parallelism optimization for GPUs
• Xu and Gregg, 2015, Exploiting Hyper-Loop Parallelism in Vectorization to Improve Memory Performance on CUDA GPGPU
• Bhatt and Bhadka, 2015, Extension of Context Free Grammar for Intermediate Code and Peephole Optimization Rule Parsers
• Wörteler and others, 2015, Function inlining in XQuery 3.0 optimization
• Dolgorukova, 2015, Implementation of memory scalability approach for llvm-based link-time optimization and static analyzing systems
• Bertolli and others, 2015, Integrating GPU support for OpenMP offloading directives into Clang
• Khaldi and others, 2015, LLVM parallel intermediate representation
• Hayashi and others, 2015, LLVM-based communication optimizations for PGAS programs
• Ditu, 2015, Model-Based Function Call Code Generation and Stack Management in Retargetable Compilers Application Binary Interface Modeling of Stack Layout and Function Call Sequence
• Ghica and Tapus, 2015, Optimized retargetable compiler for embedded processors - GCC vs LLVM
• Souza and others, 2015, Portable Explicit Vectorization Intrinsics
• Lopes and others, 2015, Provably correct peephole optimizations with alive
• Porpodas and others, 2015, PSLP Padded SLP automatic vectorization
• Yi and others, 2015, Register Allocation for QEMU Dynamic Binary Translation Systems
• Jinlong Xu and others, 2015, SIMD vectorization of nested loop based on strip mining
• Mulati and others, 2015, The Hybrid ColorAnt-RT Algorithms and an Application to Register Allocation
• Jackson, 2015, The Vectorization of Digital Imagery Image Tracing
• Eisl, 2015, Trace register allocation
• You and Chen, 2015, Vector-aware register allocation for GPU shader processors
• Seaton and others, 2015, Vectorization Advice
• Karrenberg, 2015, Whole-Function Vectorization

8 concern the calling convention and the binary interface directly, which is a strikingly small number for a subject every compiler must settle.

• Hammond and others, 2023, MPI Application Binary Interface Standardization
• Zheng and others, 2020, Application Binary Interface ABI
• Doronin, 2019, PROBLEM RESEARCH AND DEVELOPMENT OF A TOOL FOR CHECKING APPLICATION BINARY INTERFACE COMPATIBILITY OF VIRTUAL METHOD TABLES
• Van Hoey, 2019, Stack Alignment and Stack Frame
• Ambhati and others, 2018, A Generic stack frame work for Internet Of Things
• Caldwell and Chiba, 2017, Reducing calling convention overhead in object-oriented programming on embedded ARM thumb-2 platforms
• Miura and others, 2016, Development of Thermoplastic CFRP for Stack Frame
• Sukha, 2015, A Compiler-Runtime Application Binary Interface for Pipe-While Loops

Static analysis supplies the technique the other five borrow

Abstract interpretation is the machinery underneath most of what the preceding sections describe. The stack analyses, the cache analyses and the resource analyses are all instances of it, and the 604 records here are the general method rather than any one application of it.

• Shi and others, 2026, Abstract Interpretation with Confidence Quantifying the Precision of Dataflow Analysis with Probabilities
• Mastroeni and Pasqua, 2026, Abstract Interpretation-based Verification for Confidentiality Information Hiding and Code Protection by Abstract Interpretation
• Singh and others, 2026, Abstract Interpretation-Driven Deep Learning Framework for Cross-Domain Data Classification Using XCovNet With Weighted Binary Cross-Entropy SoftMax Loss
• Leão and others, 2026, Android Malware Detection through Static Analysis Using Machine Learning
• Venkatarao and others, 2026, Automated Code Review and Quality Assurance System Using Static Analysis and Complexity Evaluation in Flask-Based Web Application
• Lekssays, 2026, Bridging Code Property Graphs and Language Models for Program Analysis
• Yang and others, 2026, ContractFull a rapid and comprehensive static analysis tool for Ethereum smart contracts
• Quantrill and others, 2026, Cracking IoT security can LLMs outsmart static analysis tools?
• Baumgartner and others, 2026, Data clumps as structural indicators in digital twin software a static analysis perspective
• Schwarz and Erhard, 2026, Data Race Detection by Digest-Driven Abstract Interpretation
• Meijer and others, 2026, Data-aware Static Analysis Improving Semantic Fault Detection in Machine Learning Code Using Data Characteristics
• Su and McMillan, 2026, Do code LLMs do static analysis?
• Rashid and others, 2026, Enhancing forecast reliability through formal verification A model checking approach for weather prediction models
• Gong and Zhang, 2026, Experience Report Insights from Deploying Educational Static Analysis in Introductory Programming Courses
• Ohlmer and others, 2026, FP-Predictor False Positive Prediction for Static Analysis Reports
• Ramires and others, 2026, Friends or Foes? Combining Static Analysis Tools and LLMs for Vulnerability Detection
• Jaoua, 2026, Integrating Static Analysis with Learning-Based Systems for Automated Code Review
• Galkovsky and Krivoseina, 2026, KINEMATIC AND STATIC ANALYSIS OF A HYDRAULIC SCISSOR LIFT TABLE
• Bardonek and Zachariasova, 2026, Leveraging design static analysis for vertical reuse Analytical interpretation and scalability behavior
• Baek and Lee, 2026, Limitations and Challenges of Applying Static Analysis Tools for Flight Software
• S and others, 2026, LLM-Driven DevSecOps for Secure Software Engineering Integrating Static Analysis, Retrieval-Augmented Generation, and Automated Vulnerability Remediation
• Lv and others, 2026, MC-PoisonVerif Model Checking-Driven Poisoning Attack Formal Verification Algorithm
• van der Linden and others, 2026, On the Energy Cost of Static Analysis Precision An Empirical Study of SpotBugs Effort Levels
• Zhang and others, 2026, SPECTRA Specification-Oriented Static Analysis for Smart Contract Security and Behavioral Contract Inference
• Maheswari and others, 2026, Static analysis and integration of IoT on safety helmet
• Iavich and others, 2026, Static Analysis Techniques for Embedded, Cyber-Physical, and Electronic Software Systems A Comprehensive Survey
• Park and others, 2026, SysDiver Lightweight and Fast Static Analysis for Windows Kernel Drivers
• Remil and Urban, 2026, Termination Resilience Static Analysis
• Monat, 2026, Try-Mopsa Relational Static Analysis in Your Pocket
• Aman and others, 2026, Typify A Lightweight Usage-driven Static Analyzer for Precise Python Type Inference
• Abdinabiev and others, 2026, Utilizing Dynamic Context and Static Analysis for Agent-Based Automated Program Repair
• Azaiez and Anisi, 2026, Verified Design of Robotic Autonomous Systems Using Probabilistic Model Checking
• Negrini, 2026, Whole-value analysis by abstract interpretation
• Nazzal and others, 2025, A Modeling and Static Analysis Approach for the Verification of Privacy and Safety Properties in Kotlin Android Apps
• Assolini and others, 2025, A Static Analysis of Entanglement
• Kern and Sinz, 2025, Abstract Interpretation of ReLU Neural Networks with Optimizable Polynomial Relaxations
• Berthelot and others, 2025, Accelerating the Static Analysis of Neural Networks by Batch Representation of Abstract Values
• Miao and others, 2025, An Extensive Empirical Study of Nondeterministic Behavior in Static Analysis Tools
• Huang and others, 2025, AURA Precise Abstract Interpretation of Probabilistic Programs with Interval Data Uncertainty
• Volokh and Halfond, 2025, Automatic Action Space Specification for Deep Reinforcement Learning in Games via Program Analysis
• Dahal and others, 2025, Automatic Name-Based Software Bug Detection via AST-Driven Static Analysis and Machine Learning
• Shen and others, 2025, BMCFuzz Hybrid Verification of Processors by Synergistic Integration of Bound Model Checking and Fuzzing
• Sindoni and others, 2025, Certifying rlive A New Proof Strategy for Liveness Model Checking
• Husák and others, 2025, Combining Static Analysis Techniques for Program Comprehension Using Slicito
• Schneider and others, 2025, Comparison of static analysis architecture recovery tools for microservice applications
• Yang and others, 2025, CSAFuzzer Fuzzing smart contracts combining with static analysis
• Song and others, 2025, Debloating Software Through Enhanced Static Analysis and Constraint Rules
• Fan and Wei, 2025, Efficient Widening Operations for Static Analysis of Bit-Vector Programs
• Kim and Kim, 2025, Empirical Analysis of Security Vulnerabilities in Open Source Software Using Static Analysis Tools
• Farasat and Posegga, 2025, Enhancing Python Code Security A Comparison of Machine Learning, ChatGPT, and Static Analysis Methods
• Li and others, 2025, Extension of high-fidelity time-domain spectral element formulation for phase-field modeling of fracture A static analysis
• Alsaegg and others, 2025, Formal modeling of a causal consistent distributed system and verification of its history via model checking using colored Petri net
• Weerasena and others, 2025, Formal verification of bioinformatics software using model checking and theorem proving
• Verbeek and others, 2025, Formally Verified Binary-Level Pointer Analysis
• Tirpankar and others, 2025, FpGuard Static-Analysis Guided Domain Exclusions for Robust Floating-Point Error Analysis
• Xu and others, 2025, GAE-HVD Graph Autoencoder-based Hybrid Vulnerability Detection via Static-Dynamic Program Analysis
• Dahlbo and others, 2025, Gamifying User Feedback Collection on Static Program Analysis Tools
• Xu and others, 2025, GoPV A Static Analyzer for Finding Blocking Concurrency Bugs Due to Misuse of Shared-Memory Synchronization in Go
• Dimovski, 2025, Imperative Program Synthesis by Abstract Static Analysis and SMT Mutations
• Singh, 2025, Improving Code Quality and Workflow Integrating Static Analysis Tools with Version Control Systems
• Bobade and Puri, 2025, Improving Software Defects Detection An In-Depth Analysis of Machine Learning Methods and Static Analysis Tools for Greater Accuracy
• Zhang and others, 2025, Interactive Cross-Language Pointer Analysis for Resolving Native Code in Java Programs
• Chapman and others, 2025, Interleaving static analysis and LLM prompting with applications to error specification inference
• Azmi, 2025, LLM-Aware Static Analysis Adapting Program Analysis to Mixed Human/AI Codebases at Scale
• Berg and others, 2025, Manim-DFA Visualising Data Flow Analysis and Abstract Interpretation Algorithms with Automated Video Generation
• Esposito and others, 2025, On the correlation between architectural smells and static analysis warnings
• Maag and others, 2025, PTSAnalysis - A Static Program Analysis Tool to Capture Inter-Function Data Dependencies
• Liu and Hua, 2025, Rusty Effectively Detecting Multilingual Rust Memory Bugs with Interprocedural Static Analysis
• Singh and others, 2025, Safety and Trust in Artificial Intelligence with Abstract Interpretation
• Andrianov and others, 2025, SOFTWARE MODEL CHECKING FOR MEMORY CONSISTENCY VERIFICATION
• Hobbs, 2025, Static Analysis
• Urban and others, 2025, Static analysis by abstract interpretation against data leakage in machine learning
• Garozi and Silva, 2025, Static Analysis for Program Execution Cost Estimation
• 康, 2025, Static Analysis of Drive Roller Based on Interference Amount of Expansion Sleeve
• Mweu and Ndia, 2025, Static Analysis Techniques for Secure Software A Systematic Review
• Dudina and Stark, 2025, Static analysis to make the most of CHERI C/C++ for existing code improving memory safety at scale
• 2025, Static Program Analysis
• Cameron and others, 2025, The Importance of Malware Awareness for Aspiring Cyber Professionals Applicability of Gamification Static Analysis Tools
• Umann and Porkoláb, 2025, Towards Better Static Analysis Bug Reports in the Clang Static Analyzer
• Li and others, 2025, Towards More Accurate Static Analysis for Taint-Style Bug Detection in Linux Kernel
• Antoniadis and others, 2025, Universal Scalability in Declarative Program Analysis with Choice-Based Combination Pruning
• Ferrando and Malvone, 2025, VITAMIN A Compositional Framework for Model Checking of Multi-Agent Systems
• Dimovski, 2025, While-guard Synthesis by Abstract Static Analysis and CHC Solving
• Yoda and others, 2025, YODA Unified Middleware for IoT Firmware Static Analysis Tools
• Malyshev and others, 2024, A Comprehensive Approach to Finding Resource Leaks via Static Analysis
• Simonnet and others, 2024, A Dependent Nominal Physical Type System for Static Analysis of Memory in Low Level Code
• Bolundut and others, 2024, A Path Sensitive and Scalable Approach for Mapping the Capabilities Required for Linux Kernel Defined System Calls Using Static Analysis Techniques
• Liu and others, 2024, A Static Analysis Tool in CS1 Student Usage and Perceptions of PythonTA
• Holter and others, 2024, Abstract Debuggers Exploring Program Behaviors using Static Analysis Results
• Soureshjani and Gorzny, 2024, Abstract Interpretation for PLONKish Circuits
• Bühler and others, 2024, Abstract Interpretation with the Eva Plug-in
• Giacobazzi and others, 2024, Adversities in Abstract Interpretation - Accommodating Robustness by Abstract Interpretation
• Drobnjaković and others, 2024, An Abstract Interpretation-Based Data Leakage Static Analysis
• Charoenwet and others, 2024, An Empirical Study of Static Analysis Tools for Secure Code Review
• Yeboah and Popoola, 2024, Analyzing User Sentiments Towards Static Analysis Tools A Study Using User Reviews
• Schlichtig, 2024, Building a Framework to Improve the User Experience of Static Analysis Tools
• Sözer, 2024, Call Graph Delta Analysis and Security Vulnerability Assessment with Static Analysis
• Samhi and others, 2024, Call Graph Soundness in Android Static Analysis
• Cui, 2024, Can large language model replace static analysis tools
• Zhang and others, 2024, Characterizing and Detecting Program Representation Faults of Static Analysis Frameworks
• Firouzi and others, 2024, ChatGPT’s Potential in Cryptography Misuse Detection A Comparative Analysis with Static Analysis Tools
• Pargaonkar, 2024, Code Quality and Static Analysis
• Alqaradaghi and Kozsik, 2024, Comprehensive Evaluation of Static Analysis Tools for Their Performance in Finding Vulnerabilities in Java Code
• van de Laar and others, 2024, Custom static analysis to enhance insight into the usage of in-house libraries
• Admiraal and others, 2024, Deriving modernity signatures of codebases with static analysis
• Monat and others, 2024, Easing maintenance of academic static analyzers
• Saeed and others, 2024, Enhancing Computer Security through Formal Verification of Cryptographic Protocols Using Model Checking and Partial Order Techniques
• Guan and Treude, 2024, Enhancing Source Code Representations for Deep Learning with Static Analysis
• Fernandes, 2024, Evaluating the Top Application Security Tools From Static Analysis to Runtime Protection
• Mineau and Lalande, 2024, Evaluating the Reusability of Android Static Analysis Tools
• Molnar and others, 2024, Exploring Complexity Issues in Junior Developer Code Using Static Analysis and FCA
• Blumschein and others, 2024, Finding Cuts in Static Analysis Graphs to Debloat Software
• Sachin Ashok Murab, 2024, Formal Methods for Security Protocol Verification Model Checking and Theorem Proving Approaches
• Li and others, 2024, Formal Modelling of Program Dependence Net for Software Model Checking
• Rezaei and others, 2024, Fragility curves for regular and irregular RC bridges via non-linear static analysis
• Panayi and others, 2024, Improving Memory Dependence Prediction with Static Analysis
• Ledent and others, 2024, Improving PSS Test Generation Using Model Checking and Conformance Testing
• Zanatta and others, 2024, Inference of access policies through static analysis
• Hashmat and others, 2024, Insights from Running 24 Static Analysis Tools on Open Source Software Repositories
• Chapman and others, 2024, Interleaving Static Analysis and LLM Prompting
• De Palma and others, 2024, Leveraging static analysis for cost-aware serverless scheduling policies
• Beugnard and Mallet, 2024, Making Application Build Safer Through Static Analysis of Naming
• Soares and others, 2024, MicroSensor Towards an Extensible Tool for the Static Analysis of Microservices Systems in Continuous Integration
• Gill and others, 2024, Model Checking Algorithms for Formal Verification in Computer Architecture
• Chiotan and Răcănel, 2024, Modelling and static analysing for a cable stayed bridge considering the construction stages
• Volkova, 2024, MODERN METHODS OF AUTOMATED SOFTWARE SECURITY ANALYSIS FROM STATIC ANALYSIS TO COMPREHENSIVE APPROACH
• Campion and others, 2024, Monotonicity and the Precision of Program Analysis
• Wang and Wang, 2024, NativeSummary Summarizing Native Binary Code for Inter-language Static Analysis of Android Apps
• Balogh and Szalay, 2024, On the Applicability of Static Analysis for System Software using CodeChecker
• Ferreirinha and Medeiros, 2024, On the Path to Buffer Overflow Detection by Model Checking the Stack of Binary Programs
• Sharma and Sharma, 2024, Parameterized Static Analysis for Weak Memory Models
• Ibrahimzada, 2024, Program Decomposition and Translation with Static Analysis
• Mazzucato and others, 2024, Quantitative Input Usage Static Analysis
• Laursen and others, 2024, Reducing Static Analysis Unsoundness with Approximate Interpretation
• Bai and others, 2024, Research on the Method of Constructing a Unified Code Scanning Platform Based on Multiple Static Analysis Tools
• Ilichev and Solovev, 2024, Revisiting Control Flow Recovery from Binaries An Abstract Interpretation-based Approach
• Chen and others, 2024, SafeCheck Detecting smart contract vulnerabilities based on static program analysis methods
• Li, 2024, Software Fault Detection Based on Program Static Analysis and Fault Tree
• Arceri and others, 2024, Speeding up static analysis with the split operator
• Halder, 2024, State-based Invariant Property Generation of Solidity Smart Contracts using Abstract Interpretation
• Venkatesh and others, 2024, Static analysis driven enhancements for comprehension in machine learning notebooks
• Dudina and Stark, 2024, Static Analysis for Transitioning to CHERI C/C++
• Deng and others, 2024, Static program analysis for IoT risk mitigation in space-air-ground integrated networks
• Behler and others, 2024, Supporting Static Program Analysis and Transformation of Quantum-Based Languages
• B and others, 2024, SUV Static Analysis Guided Unified Virtual Memory
• Yeboah and Popoola, 2024, Uncovering User Concerns and Preferences in Static Analysis Tools a Topic Modeling Approach
• Trautsch, 2024, Usefulness of Automatic Static Analysis Tools Evidence from Four Case Studies
• Wang and others, 2024, Using Run-Time Information to Enhance Static Analysis of Machine Learning Code in Notebooks
• Schnakenbeck and others, 2023, A Control Flow based Static Analysis of GRAFCET using Abstract Interpretation
• Lenarduzzi and others, 2023, A critical comparison on six static analysis tools Detection, agreement, and precision
• Zhang and others, 2023, A dynamic program analysis-based method for floating-point program precision loss detection
• Feret and Salazar, 2023, A Generic Framework to Coarse-Grain Stochastic Reaction Networks by Abstract Interpretation
• Cousot, 2023, A Personal Historical Perspective on Abstract Interpretation
• Kästner and others, 2023, Abstract Interpretation in Industry Experience and Lessons Learned
• Pal and others, 2023, Abstract Interpretation-Based Feature Importance for Support Vector Machines
• Nxumalo and others, 2023, An evaluation of approaches to model checking real-time task schedulability analysis
• Trautsch and others, 2023, Are automated static analysis tools worth it? An investigation into relative warning density and external software quality on the example of Apache open source projects
• Li and others, 2023, Assisting Static Analysis with Large Language Models A ChatGPT Experiment
• Mohammadi and others, 2023, Assume, Capture, Verify, Establish A Vocabulary for Static Program Analysis
• Mordahl, 2023, Automatic Testing and Benchmarking for Configurable Static Analysis Tools
• Singh, 2023, Building Trust and Safety in Artificial Intelligence with Abstract Interpretation
• Coward and others, 2023, Combining E-Graphs with Abstract Interpretation
• Monniaux, 2023, Completeness in Static Analysis by Abstract Interpretation A Personal Point of View
• Saan and others, 2023, Correctness Witness Validation by Abstract Interpretation
• Mastroeni and Pasqua, 2023, Domain Precision in Galois Connection-Less Abstract Interpretation
• Mordahl and others, 2023, ECSTATIC Automatic Configuration-Aware Testing and Debugging of Static Analysis Tools
• Yeboah and Popoola, 2023, Efficacy of Static Analysis Tools for Software Defect Detection on Open-Source Projects
• Bangash and others, 2023, Energy Consumption Estimation of API-usage in Smartphone Apps via Static Analysis
• Zhan and others, 2023, ErrHunter Detecting Error-Handling Bugs in the Linux Kernel Through Systematic Static Analysis
• Dimovski, 2023, Error Invariants for Fault Localization via Abstract Interpretation
• Tran and others, 2023, Exploring the Potential of Frama-C in IoT Static Analysis
• Bédard and Hallé, 2023, Formal verification for event stream processing Model checking of BeepBeep stream processing pipelines
• Rao and Wang, 2023, Formal Verification of Autonomous Vehicles Bridging the Gap between Model-Based Design and Model Checking
• Fekih and others, 2023, Formal Verification of Smart Contracts Based on Model Checking An Overview
• Kwon and Kwon, 2023, Formal Verification of STPA with Model Checking
• Dimovski, 2023, Generalized Program Sketching by Abstract Interpretation and Logical Abduction
• Usova, 2023, Generating a Formalized REST API Definition Language for a Dynamic Framework Without Annotations Using Static Analysis Tools
• Milanese and Miné, 2023, Generation of Violation Witnesses by Under-Approximating Abstract Interpretation
• Thilak, 2023, Linear Static Analysis Using FEASTSMT Software
• Zhou and others, 2023, MIPAD Mini Program Analysis for Clone Detection using Static Analysis Techniques
• Chandra and others, 2023, Mobile Application Security in the Health Care and Finance Sector with Static Analysis Tools MobSF
• Huisman and Wijs, 2023, Model Checking Algorithms
• Mehdi Pourhashem Kallehbasti and Ghafari, 2023, Naturalistic Static Program Analysis
• Blanco-Claraco and others, 2023, OpenBeam Off-Line and On-Line Tools to Solve Static Analysis of Mechanical Structures
• Zhou and others, 2023, Program completeness verification mechanism based on static analysis
• Liu and others, 2023, Program Repair Guided by Datalog-Defined Static Analysis
• Lemerre, 2023, Reverse Template Processing Using Abstract Interpretation
• JANA, 2023, Sensitive Information Leakage Analysis of Database Code by Abstract Interpretation
• Arceri and others, 2023, Speeding up Static Analysis with the Split Operator
• Urban, 2023, Static Analysis for Data Scientists
• Ferenczi and Tóth, 2023, Static analysis for safe software upgrade
• Negrini and others, 2023, Static Analysis of Data Transformations in Jupyter Notebooks
• Tu and others, 2023, Static Analysis of Innovative Prefabricated Grid Steel-Concrete Composite Roof Structures
• Park and others, 2023, Static Analysis of JNI Programs via Binary Decompilation
• Chen and others, 2023, Static analysis of linear absolute value equalities among variables of a program
• Haas and others, 2023, Static Analysis of Memory Models for SMT Encodings
• Yang, 2023, Static analysis of plane and space frames
• Phan and others, 2023, The Challenges of Shift Left Static Analysis
• Babati and Pataki, 2023, The Role of Implementation-Specific Static Analysis
• Durmaz and others, 2023, TimeInspector A Static Analysis Approach for Detecting Timing Attacks
• Trautsch and others, 2023, What really changes when developers intend to improve their source code a commit-level study of static metric value and static analysis warning changes
• Lenarduzzi and others, 2022, A Critical Comparison on Six Static Analysis Tools Detection Agreement and Precision
• Nachtigall and others, 2022, A large-scale study of usability criteria addressed by static analysis tools
• Giordano and others, 2022, A Preliminary Conceptualization and Analysis on Automated Static Analysis Tools for Vulnerability Detection in Android Apps
• Subotić and others, 2022, A static analysis framework for data science notebooks
• Bau and others, 2022, Abstract interpretation of Michelson smart-contracts
• Bruni and others, 2022, Abstract interpretation repair
• Mendonça and Kalinowski, 2022, An empirical investigation on the challenges of creating custom static analysis rules for defect localization
• Malm and others, 2022, An Evaluation of General-Purpose Static Analysis Tools on C/C++ Test Code
• Kitahara and others, 2022, An Investigation of Formal Verification of Control Policy of Multi-Car Elevator Systems Using Statistical Model Checking
• Park and others, 2022, Automatically deriving JavaScript static analyzers from specifications using Meta-level static analysis
• Mehrpour and LaToza, 2022, Can static analysis tools find more defects?
• Amilon and others, 2022, Deductive Verification Based Abstraction for Software Model Checking
• Kang and others, 2022, Detecting false alarms from automatic static analysis tools
• Romano and others, 2022, Do Static Analysis Tools Affect Software Quality when Using Test-driven Development?
• Do and Bodden, 2022, Explaining Static Analysis With Rule Graphs
• HASEGAWA and YOKOGAWA, 2022, Formal Verification for Node-Based Visual Scripts Using Symbolic Model Checking
• Nam and Kil, 2022, Formal Verification of Blockchain Smart Contracts via ATL Model Checking
• Zhang and others, 2022, Formal Verification of Hierarchical Ptolemy II Synchronous-Reactive Models with Bounded Model Checking
• Piskachev and others, 2022, How far are German companies in improving security through static program analysis tools?
• Kashyap and Jana, 2022, Integrity Constraint Verification of Structured Query Language by Abstract Interpretation
• Monil and others, 2022, MAPredict Static Analysis Driven Memory Access Prediction Framework for Modern CPUs
• Garanina and others, 2022, Model Checking Meets Auto-Tuning of High-Performance Programs
• Tran, 2022, Model Checking Techniques Enable Schedulability Analysis of Real-Time Systems
• Pecorelli and others, 2022, On the adequacy of static analysis warnings with respect to code smell prediction
• Campion and others, 2022, Partial In Completeness in abstract interpretation limiting the imprecision in program analysis
• Jeong and others, 2022, Performance Comparison and Analysis of Static Analysis Tools Based on Vulnerability Analysis of Open Sources
• Giacobazzi and Mastroeni, 2022, Property-Driven Code Obfuscations Reinterpreting Jones-Optimality in Abstract Interpretation
• Dimovski and others, 2022, Several lifted abstract domains for static analysis of numerical program families
• Yang and others, 2022, Simulink Model Static Analysis Results based on Abstract Interpretation
• Volokh and Halfond, 2022, Static Analysis for Automated Identification of Valid Game Actions During Exploration
• Aslanyan and others, 2022, Static Analysis Methods For Memory Leak Detection A Survey
• Mo, 2022, Static Analysis of Interval Finite Element
• Tripathi and others, 2022, Static Analysis of Multi-Metal Usage in Grid Stiffened Structures
• Patil and others, 2022, Static analysis of shape memory alloy SMA reinforced composite
• Chitre and others, 2022, The road not taken exploring alias analysis based optimizations missed by the compiler
• Mastroeni and Pasqua, 2022, Verifying opacity by abstract interpretation
• Siavvas and others, 2021, A hierarchical model for quantifying software security based on static analysis alerts and software metrics
• Jeon and others, 2021, A practical algorithm for learning disjunctive abstraction heuristics in static program analysis
• Park and others, 2021, Accelerating JavaScript static analysis via dynamic shortcuts
• Sun and others, 2021, An Interactive Ranking Algorithm for Program Static Analysis
• Cuadrado and others, 2021, AnATLyzer Static Analysis of ATL Model Transformations
• Ueda and others, 2021, Automatically Customizing Static Analysis Tools to Coding Rules Really Followed by Developers
• 2021, Basics of Model Checking
• Chen and others, 2021, Boosting static analysis accuracy with instrumented test executions
• Ljungberg and others, 2021, Case Study on Data-Driven Deployment of Program Analysis on an Open Tools Stack
• Bartsch and others, 2021, Compositional Fault Propagation Analysis in Embedded Systems using Abstract Interpretation
• Stein and others, 2021, Demanded abstract interpretation
• Tiganov and others, 2021, Designing UIs for Static Analysis Tools
• 2021, Detecting security vulnerabilities with static analysis A case study
• Filus and others, 2021, Efficient Feature Selection for Static Analysis Vulnerability Prediction
• Yousaf and others, 2021, Efficient Identification of Race Condition Vulnerability in C code by Abstract Interpretation and Value Analysis
• ter Beek and others, 2021, Efficient static analysis and verification of featured transition systems
• Groce and others, 2021, Evaluating and Improving Static Analysis Tools Via Differential Mutation Analysis
• Zhu and others, 2021, Failure Analysis of Static Analysis Software Module Based on Big Data Tendency Prediction
• Aziz, 2021, Formal Analysis by Abstract Interpretation
• Schwarz and others, 2021, Improving Thread-Modular Abstract Interpretation
• Bolotnikov and Borodin, 2021, Interprocedural Static Analysis for Finding Bugs in Go Programs
• Dimovski, 2021, Lifted termination analysis by abstract interpretation and its applications
• Stepanov and others, 2021, Making Bounded Model Checking Interprocedural in Static Analysis Style
• 2021, Model Checking Quantum Automata
• Jbeli and Sbai, 2021, On Improving Model Checking of Time Petri Nets and Its Application to the Formal Verification
• Yu and Palsberg, 2021, Quantum abstract interpretation
• Ngo and others, 2021, Ranking Warnings of Static Analysis Tools Using Representation Learning
• Ballabriga and others, 2021, Relational abstract interpretation of arrays in assembly code
• Védrine and others, 2021, Runtime Abstract Interpretation for Numerical Accuracy and Robustness
• Tahaei and others, 2021, Security Notifications in Static Analysis Tools Developers’ Attitudes, Comprehension, and Ability to Act on Them
• Akremi, 2021, Software Security Static Analysis False Alerts Handling Approaches
• Nxumalo and others, 2021, Spotlight Abstraction in Model Checking Real-Time Task Schedulability
• Agarwal and others, 2021, Stateless Model Checking Under a Reads-Value-From Equivalence
• Ferrara and others, 2021, Static analysis for dummies experiencing LiSA
• Delmas and others, 2021, Static Analysis of Endian Portability by Abstract Interpretation
• Chen and others, 2021, Static Analysis of Resource Usage Bounds for Imperative Programs
• Goryuk and Lavrovsky, 2021, Static analysis of software source code based on the Fortify Static Code Analyzer solution
• Talib and Doh, 2021, Static Analysis Tools Against Cross-site Scripting Vulnerabilities in Web Applications An Analysis
• Staderini and others, 2021, Static Analysis Tools Applied to Smart Contracts
• Thomson, 2021, Static Analysis An Introduction
• Ami and others, 2021, Systematic Mutation-Based Evaluation of the Soundness of Security-Focused Android Static Analysis Techniques
• Monniaux, 2021, The complexity gap in the static analysis of cache accesses grows if procedure calls are added
• Deng and Cousot, 2021, The Systematic Design of Responsibility Analysis by Abstract Interpretation
• Al-Bataineh and others, 2021, Towards More Reliable Automated Program Repair by Integrating Static Analysis Techniques
• Negrini and others, 2021, Twinning Automata and Regular Expressions for String Static Analysis
• Zampetti and others, 2021, Using code reviews to automatically configure static analysis tools
• Fang and others, 2021, Zero Knowledge Static Program Analysis
• Ami and others, 2021, µSE Mutation-Based Evaluation of Security-Focused Static Analysis Tools for Android
• Larsen and Legay, 2020, 30 Years of Statistical Model Checking
• Henglein and others, 2020, A Formally Verified Static Analysis Framework for Compositional Contracts
• Trautsch and others, 2020, A longitudinal study of static analysis warning evolution and the effects of PMD on software quality in Apache open source projects
• Deshlahre and Tiwari, 2020, A Review on Benchmarking Comparing the Static Analysis Tools SATs in Web Security
• Rimawi, 2020, A Static Analysis of Android Source Code for Design Patterns Usage
• Keidel and Erdweg, 2020, A Systematic Approach to Abstract Interpretation of Program Transformations
• Kashyap and others, 2020, API analytics for curating static analysis rules
• Kim and others, 2020, Automatic Malicious Code Classification System through Static Analysis Using Machine Learning
• Matsuura and others, 2020, Automatic Verification of Behavior of UML Requirements Specifications using Model Checking
• Marcilio and Bonifácio, 2020, Automatically Fixing Static Analysis Tools Violations
• Omar and others, 2020, Binary-level data dependence analysis of hot execution regions using abstract interpretation at runtime
• Aslanyan and others, 2020, BinSide Static Analysis Framework for Defects Detection in Binary Code
• Lee and others, 2020, Broadening horizons of multilingual static analysis
• Do and others, 2020, Debugging Static Analysis
• Chouhan and Banda, 2020, Formal Verification of Heuristic Autonomous Intersection Management Using Statistical Model Checking
• Bembenek and others, 2020, Formulog Datalog for SMT-based static analysis
• Buinevich and Izrailov, 2020, Generalized model of software code`s static analysis based on machine learning for vulnerabilitys search
• Ghaleb and Pattabiraman, 2020, How effective are smart contract analysis tools? evaluating smart contract static analysis tools using bug injection
• Bai and others, 2020, iDEA Static Analysis on the Security of Apple Kernel Drivers
• Medeiros and Neves, 2020, Impact of Coding Styles on Behaviours of Static Analysis Tools for Web Applications
• WU and YAMANE, 2020, Model Checking of Real-Time Properties for Embedded Assembly Program Using Real-Time Temporal Logic RTCTL and Its Application to Real Microcontroller Software
• Anderson, 2020, Modernizing Static Analysis Tools to Facilitate Integrations
• Beckert and others, 2020, Modular Verification of JML Contracts Using Bounded Model Checking
• D’Abruzzo Pereira and Vieira, 2020, On the Use of Open-Source C/C++ Static Analysis Tools in Large Projects
• Phulia and others, 2020, OOElala order-of-evaluation based alias analysis for compiler optimization
• Solovev and others, 2020, Practical Abstract Interpretation of Binary Code
• Manuel and others, 2020, Probabilistic Abstract Interpretation Sound Inference and Application to Privacy
• Fegade and Wimmer, 2020, Scalable pointer analysis of data structures using semantic models
• Kulik and others, 2020, Security Verification of Industrial Control Systems using Partial Model Checking
• Bak and others, 2020, SmartVisual a visualisation tool for SmartThings IoT Apps using static analysis
• Ferrara and others, 2020, Static analysis for discovering IoT vulnerabilities
• Mamedov and others, 2020, Static Analysis of Resource Consumption in Programs Using Rewriting Rules
• Ashok and others, 2020, Statistical Model Checking Black or White?
• Wood and others, 2020, Supporting robotic software migration using static analysis and model-driven engineering
• Tiganov and others, 2020, SWAN a static analysis framework for swift
• Barthe and others, 2020, System-Level Non-interference of Constant-Time Cryptography. Part II Verified Static Analysis and Stealth Memory
• van Tonder and Le Goues, 2020, Tailoring programs for static analysis via program transformation
• Braithwaite and others, 2020, Tendermint Blockchain Synchronization Formal Specification and Model Checking
• Shi, 2020, The Method and Static Analysis of Making Well Logging Interpretation Standard of Oil-water Formation by Network
• Skalka and others, 2020, Types and Abstract Interpretation for Authorization Hook Advice
• Molnar and others, 2020, Using static analysis tools to assist student project evaluation
• Hoshieah and others, 2019, A Static Analysis of Android Source Code for Lifecycle Development Usage Patterns
• Souri and others, 2019, A symbolic model checking approach in formal verification of distributed systems
• Campion and others, 2019, Abstract Interpretation of Indexed Grammars
• Wu and Wang, 2019, Abstract interpretation under speculative execution
• Goldsmith, 2019, Adventures in commercial-grade static analysis keynote
• Koc and others, 2019, An Empirical Assessment of Machine Learning Approaches for Triaging Reports of a Java Static Analysis Tool
• Pereira and others, 2019, An Exploratory Study on Machine Learning to Combine Security Vulnerability Alerts from Static Analysis Tools
• Delmas and Miné, 2019, Analysis of Software Patches Using Numerical Abstract Interpretation
• Yamaguchi and others, 2019, Application of Abstract Interpretation to the Automotive Electronic Control System
• Meng and others, 2019, AppScalpel Combining static analysis and outlier detection to identify and prune undesirable usage of sensitive data in Android applications
• Marcilio and others, 2019, Are Static Analysis Violations Really Fixed? A Closer Look at Realistic Usage of SonarQube
• V C and others, 2019, Assessment of Quality of Program Based on Static Analysis
• Rivera and Meyer, 2019, AutoAlias Automatic Variable-Precision Alias Analysis for Object-Oriented Programs
• Czibula and others, 2019, Automatic Algorithmic Complexity Determination Using Dynamic Program Analysis
• Zhang and others, 2019, BDA practical dependence analysis for binary executables by unbiased whole-program path sampling and per-path abstract interpretation
• Tran and Aoki, 2019, Conformance Testing of Schedulers for DSL-based Model Checking
• Chopra and others, 2019, Data Races and Static Analysis for Interrupt-Driven Kernels
• Solovev and others, 2019, Decoding of machine instructions for abstract interpretation of binary code
• Meyer and Wolff, 2019, Decoupling lock-free data structures from memory reclamation for static analysis
• Boutonnet and Halbwachs, 2019, Disjunctive Relational Abstract Interpretation for Interprocedural Program Analysis
• Dmitry S. and Roman E., 2019, Effectiveness Evaluation of Static Analysis for Searching Natural Semantic Defects of Program Objects
• Trautsch, 2019, Effects of Automated Static Analysis Tools A Multidimensional View on Quality Evolution
• Şora and Chirila, 2019, Finding key classes in object-oriented software systems by techniques based on static analysis
• Wang and Tepfenhart, 2019, Formal Verification by Model Checking
• Vassallo and others, 2019, How developers engage with static analysis tools in different contexts
• Imtiaz and others, 2019, How Do Developers Act on Static Analysis Alerts? An Empirical Study of Coverity Usage
• Nguyen and others, 2019, Integrating Static Program Analysis Tools for Verifying Cautions of Microcontroller
• Schubert and others, 2019, Know your analysis how instrumentation aids understanding static analysis
• Schnappinger and others, 2019, Learning a Classifier for Prediction of Maintainability Based on Static Analysis Tools
• Dimovski, 2019, Lifted static analysis using a binary decision diagram abstract domain
• Papamichail and others, 2019, Measuring the reusability of software components using static analysis metrics and reuse rate information
• Wagner, 2019, Modern Static Analysis of Obfuscated Code
• Nielsen and others, 2019, Nodest feedback-driven static analysis of Node.js applications
• Walker and others, 2019, On Limitations of Modern Static Analysis Tools
• Fijalkow and others, 2019, On the Monniaux Problem in Abstract Interpretation
• Abdulla and others, 2019, Optimal stateless model checking for reads-from equivalence under sequential consistency
• Bavishi and others, 2019, Phoenix automated data-driven synthesis of repairs for static analysis violations
• Lu and Xue, 2019, Precision-preserving yet fast object-sensitive pointer analysis with partial context sensitivity
• Yin, 2019, Property Oriented Verification Via Iterative Abstract Interpretation
• Ouadjaout and Miné, 2019, Quantitative static analysis of communication protocols using abstract Markov chains
• Deng and Cousot, 2019, Responsibility Analysis by Abstract Interpretation
• Naik, 2019, Rethinking Static Analysis by Combining Discrete and Continuous Reasoning
• Krishnamurthy and others, 2019, Scientific Developers v/s Static Analysis Tools Vision and Position Paper
• Jang, 2019, Software Security Vulnerability Improvement Using Public Static Analysis Tools
• Ly and others, 2019, Soundness of a Dataflow Analysis for Memory Monitoring
• Korovin, 2019, Space tether system in a circular orbit Static analysis
• Zyrianov and others, 2019, srcPtr A Framework for Implementing Static Pointer Analysis Approaches
• Hobbs, 2019, Static Analysis
• Ivanov and Schupp, 2019, Static Analysis for Worst-Case Battery Utilization
• Reichenbach and others, 2019, Static Analysis of a Two-Platform Planar Cable-Driven Parallel Robot with Unlimited Rotation
• Ballabriga and others, 2019, Static Analysis of Binary Code with Memory Indirections Using Polyhedra
• Urban, 2019, Static Analysis of Data Science Software
• Arceri and Mastroeni, 2019, Static Program Analysis for String Manipulation Languages
• Cousot, 2019, Syntactic and Semantic Soundness of Structural Dataflow Analysis
• Belonogov, 2019, Techniques for iterative static analysis of a quad-orifice electrohydraulic steering actuator of rocket stages
• Crespi Reghizzi and others, 2019, Translation Semantics and Static Analysis
• Braga and others, 2019, Understanding How to Use Static Analysis Tools for Detecting Cryptography Misuse in Software
• Zhang and others, 2018, A Novel Memory Leak Classification for Evaluating the Applicability of Static Analysis Tools
• Cha and others, 2018, A scalable learning algorithm for data-driven program analysis
• Urban and others, 2018, Abstract Interpretation of CTL Properties
• Alpernas and others, 2018, Abstract Interpretation of Stateful Networks
• Nunes and others, 2018, An empirical study on combining diverse static analysis tools for web security vulnerabilities based on development scenarios
• Cheirdari and Karabatis, 2018, Analyzing False Positive Source Code Vulnerabilities Using Static Analysis Tools
• Kupferman, 2018, Automata Theory and Model Checking
• Nunes and others, 2018, Benchmarking Static Analysis Tools for Web Security
• Griggio and others, 2018, Certifying Proofs for LTL Model Checking
• Shankar, 2018, Combining Model Checking and Deduction
• Miele, 2018, Comparative Assessment of Static Analysis Tools for Software Vulnerability
• Vassallo and others, 2018, Context is king The developer perspective on the usage of static analysis tools
• Novikov and others, 2018, Detecting the use of unsafe data in software of embedded systems by means of static analysis methodology
• Mandrioli and others, 2018, Dynamic Models for the Formal Verification of Big Data Applications Via Stochastic Model Checking
• Holzmann, 2018, Explicit-State Model Checking
• Algaith and others, 2018, Finding SQL Injection and Cross Site Scripting Vulnerabilities with Diverse Static Analysis Tools
• Gu and others, 2018, Formal verification of an autonomous wheel loader by model checking
• Harman and O’Hearn, 2018, From Start-ups to Scale-ups Opportunities and Open Problems for Static and Dynamic Program Analysis
• Nguyen Quang Do and Bodden, 2018, Gamifying static analysis
• Kobayashi and others, 2018, Higher-Order Program Verification via HFL Model Checking
• Liqat and others, 2018, Inferring Energy Bounds via Static Program Analysis and Evolutionary Modeling of Basic Blocks
• Sadowski and others, 2018, Lessons from building static analysis tools at Google
• Lee and others, 2018, MemFix static analysis-based repair of memory deallocation errors for C
• Riesco, 2018, Model Checking Parameterized by the Semantics in Maude
• Zhao and others, 2018, Neural-augmented static analysis of Android communication
• Hétier and Boucheneb, 2018, On Handling Source Code Positions and Local Variables in LTL Software Model Checking
• Guo, 2018, Performance analysis of Israeli-Jalfon’s algorithm using probabilistic model checking
• Aslanyan, 2018, Platform for interprocedural static analysis of binary code
• Seladji and Qu, 2018, Polyhedron over-approximation for complexity reduction in static analysis
• Li and others, 2018, Precision-guided context sensitivity for pointer analysis
• Alavani and others, 2018, Predicting Execution Time of CUDA Kernel Using Static Analysis
• Meirelles and others, 2018, Predicting Software Flaws with Low Complexity Models based on Static Analysis Data
• Flynn and others, 2018, Prioritizing alerts from multiple static analysis tools, using classification models
• Sagonas, 2018, Progress on Algorithms for Stateless Model Checking
• Sherman, 2018, Redesigning Soot’s data-flow analysis framework for abstract interpretation
• Selmadji and others, 2018, Refactoring Object-Oriented Applications for a Deployment in the Cloud - Workflow Generation based on Static Analysis of Source Code
• Muske and others, 2018, Repositioning of static analysis alarms
• Yan, 2018, Research of Automatic Scoring of Student Programs Based on Static Analysis
• Bodden, 2018, Self-adaptive static analysis
• Grech and others, 2018, Shooting from the heap ultra-scalable static analysis with heap snapshots
• Srisopha and Alfayez, 2018, Software quality through the eyes of the end-user and static analysis tools
• Omri and others, 2018, Static Analysis and Code Complexity Metrics as Early Indicators of Software Defects
• Rabbi and others, 2018, Static Analysis of Conformance Preserving Model Transformation Rules
• Toffalini and others, 2018, Static analysis of context leaks in android applications
• SATO and SHIBUYA, 2018, Static Analysis of Elastic Plate with Dissimilar Interface based on Kernel Approximation
• Behravan Rad, 2018, Static analysis of non-uniform 2D functionally graded auxetic-porous circular plates interacting with the gradient elastic foundations involving friction force
• Fromherz and others, 2018, Static Value Analysis of Python Programs by Abstract Interpretation
• Smith, 2018, Supporting Effective Strategies for Resolving Vulnerabilities Reported by Static Analysis Tools
• Namjoshi and Pavlinovic, 2018, The Impact of Program Transformations on Static Program Analysis
• Alkhalid and Labiche, 2018, Towards GUI Functional Verification using Abstract Interpretation
• Evans, 2018, Verifying Qthreads Is Model Checking Viable for User Level Tasking Runtimes?
• Querel and Rigby, 2018, WarningsGuru integrating statistical bug models with static analysis to provide timely and specific bug warnings
• Menshchikov and Lepikhin, 2017, 5W+1H Static Analysis Report Quality Measure
• Imparato and others, 2017, A Comparative Study of Static Analysis Tools for AUTOSAR Automotive Software Components Development
• Arusoaie and others, 2017, A Comparison of Open-Source Static Analysis Tools for Vulnerability Detection in C/C++ Code
• Ibrar and others, 2017, A Study of Static Analysis Tools to Detect Vulnerabilities of Branchless Banking Applications in Developing Countries
• Titolo and others, 2017, An Abstract Interpretation Framework for the Round-Off Error Analysis of Floating-Point Programs
• Shen, 2017, Android Security via Static Program Analysis
• Moscato and others, 2017, Automatic Estimation of Verified Floating-Point Round-Off Errors via Static Analysis
• Jiang and others, 2017, Block-Wise Abstract Interpretation by Combining Abstract Domains with SMT
• Martignano, 2017, Bounded model checking and abstract interpretation of large C codebases
• Lidman and Svenningsson, 2017, Bridging Static and Dynamic Program Analysis using Fuzzy Logic
• Bruni and others, 2017, Code Obfuscation Against Abstract Model Checking Attacks
• Bakhirkin and Monniaux, 2017, Combining Forward and Backward Abstract Interpretation of Horn Clauses
• Desai and others, 2017, Combining Model Checking and Runtime Verification for Safe Robotics
• Yan and others, 2017, Comprehensive Static Analysis for Configurable Software via Combinatorial Instantiation
• Ozeri and others, 2017, Conjunctive Abstract Interpretation Using Paramodulation
• Moore and Lawford, 2017, Correct Safety Critical Hardware Descriptions via Static Analysis and Theorem Proving
• Pashchenko and others, 2017, Delta-Bench Differential Benchmark for Static Analysis Security Testing Tools
• Park and others, 2017, Detecting False Negatives in Static Analysis Tools Using Test Code Mutants
• Krainz and Philippsen, 2017, Diff Graphs for a fast Incremental Pointer Analysis
• Krafczyk and Peleska, 2017, Effective Infinite-State Model Checking by Input Equivalence Class Partitioning
• Zhang and others, 2017, Effective interactive resolution of static analysis alarms
• Singh and others, 2017, Evaluating how static analysis tools can reduce code review effort
• Aloraini and Nagappan, 2017, Evaluating State-of-the-Art Free and Open Source Static Analysis Tools Against Buffer Errors in Android Apps
• Bruschi and others, 2017, Formal Verification of ARP Address Resolution Protocol Through SMT-Based Model Checking - A Case Study
• Bersani and others, 2017, Formal verification of data-intensive applications through model checking modulo theories
• Mahmoudi and Mourlin, 2017, Formal verification of mobile orchestration agents Model checking for orchestration verification
• Ngo and Legay, 2017, Formal verification of probabilistic SystemC models with statistical model checking
• Kejstová and others, 2017, From Model Checking to Runtime Verification and Back
• Boutonnet and Halbwachs, 2017, Improving the results of program analysis by abstract interpretation beyond the decreasing sequence
• Fang and others, 2017, Infer Precise Program Invariant Using Abstract Interpretation with Recurrence Solving
• Gou and others, 2017, Medical software bug prediction based on static analysis
• Larsen and others, 2017, Memory-Efficient Tactics for Randomized LTL Model Checking
• Wolf, 2017, Model Checking Concurrency and Causality
• Rocha and others, 2017, Model Checking Embedded C Software Using k-Induction and Invariants
• Anderson, 2017, More Software Safety A Static Analysis Tools Perspective
• Belevantsev, 2017, Multilevel static analysis for improving program quality
• Wei and others, 2017, OASIS prioritizing static analysis warnings for Android apps based on app user reviews
• Nunes and others, 2017, On Combining Diverse Static Analysis Tools for Web Security An Empirical Study
• Wang and others, 2017, Partitioned Memory Models for Program Analysis
• Braga and others, 2017, Practical Evaluation of Static Analysis Tools for Cryptography Benchmarking Method and Case Study
• Monat and Miné, 2017, Precise Thread-Modular Abstract Interpretation of Concurrent Programs Using Relational Interference Abstractions
• Kwiatkowska and others, 2017, Probabilistic Model Checking Advances and Applications
• Orlov, 2017, Program Source Code Static Analysis for Memory Access Error Detection Using Backwards Execution
• Nicolay and others, 2017, Purity analysis for JavaScript through abstract interpretation
• Ouadjaout and Miné, 2017, Quantitative Static Analysis of Communication Protocols Using Abstract Markov Chains
• Midtgaard and Møller, 2017, QuickChecking static analysis properties
• Abe and others, 2017, Reordering Control Approaches to State Explosion in Model Checking with Memory Consistency Models
• Jana and others, 2017, Scaling Bounded Model Checking by Transforming Programs with Arrays
• Matsuura and others, 2017, Security Requirements Verification for Existing Systems with Model Checking Technique and UML
• Markin and Ermolitsky, 2017, Simple Type-Based Alias Analysis for a VLIW Processor
• Khoroshilov, 2017, Software Model Checking of Linux Device Drivers
• Beyer and Lemberger, 2017, Software Verification Testing vs. Model Checking
• Kübler and others, 2017, SootKeeper runtime reusability for modular static analysis
• 2017, Static Analysis
• Newman and others, 2017, Static Analysis and Dimensional Optimization of a Cable-Driven Parallel Robot
• Garbervetsky and others, 2017, Static analysis for optimizing big data queries
• Botbol and others, 2017, Static Analysis of Communicating Processes Using Symbolic Transducers
• 2017, STATIC ANALYSIS OF CONNECTING ROD
• Miné, 2017, Static Analysis of Embedded Real-Time Concurrent Software with Dynamic Priorities
• Cuadrado and others, 2017, Static Analysis of Model Transformations
• So and Oh, 2017, Synthesizing Imperative Programs from Examples Guided by Static Analysis
• Andreasen and others, 2017, Systematic approaches for increasing soundness and precision of static analyzers
• Novikov and others, 2017, The approach to finding errors in program code based on static analysis methodology
• Kusano and Wang, 2017, Thread-modular static analysis for relaxed memory models
• Garbervetsky and others, 2017, Toward full elasticity in distributed static analysis the case of callgraph analysis
• Miné, 2017, Tutorial on Static Inference of Numeric Invariants by Abstract Interpretation
• Buckers and others, 2017, UAV Warnings from multiple Automated Static Analysis Tools at a glance
• Guaman and others, 2017, Use of SQALE and tools for analysis and identification of code technical debt through static analysis
• Ferrara and others, 2017, Using Abstract Interpretation to Correct Synchronization Faults
• Breese and others, 2017, Using Static Analysis for Automated Assignment Grading in Introductory Programming Classes Abstract Only
• Yoshimura and Kono, 2016, A Case for Static Analysis of Linux to Find Faults in Interrupt Request Handlers
• Cho, 2016, A Study on Safety Design through Static Analysis at Car Seat Frame
• Ranzato, 2016, Abstract Interpretation of Supermodular Games
• Blazy and others, 2016, An abstract memory functor for verified C static analyzers
• Beller and others, 2016, Analyzing the State of Static Analysis A Large-Scale Evaluation in Open Source Software
• Kästner and Ferdinand, 2016, Applying Abstract Interpretation to Verify EN-50128 Software Safety Requirements
• Arbaugh, 2016, Automated Program Analysis for Cybersecurity APAC
• Ramler and others, 2016, Automated Static Analysis of Unit Test Code
• Christakis and Wüstholz, 2016, Bounded Abstract Interpretation
• Holzmann, 2016, Cobra a light-weight tool for static and dynamic program analysis
• Yamaguchi and others, 2016, Combining requirement mining, software model checking and simulation-based verification for industrial automotive systems
• Ostberg and others, 2016, Does personality influence the usage of static analysis tools?
• Buchholz and others, 2016, Equivalence and Minimization for Model Checking Labeled Markov Chains
• Schordan and others, 2016, Evaluation and Reproducibility of Program Analysis and Verification Track Introduction
• Medvet and Mercaldo, 2016, Exploring the Usage of Topic Modeling for Android Malware Static Analysis
• Metcalf and others, 2016, Extracting configuration parameter interactions using static analysis
• Kusano and Wang, 2016, Flow-sensitive composition of thread-modular abstract interpretation
• Suzanne and Miné, 2016, From Array Domains to Abstract Interpretation Under Store-Buffer-Based Memory Models
• Hamilton, 2016, Generating Counterexamples for Model Checking by Transformation
• Kanvar and Khedker, 2016, Heap Abstractions for Static Analysis
• Barik, 2016, How should static analysis tools explain anomalies to developers?
• Baloglu, 2016, How to find and fix software vulnerabilities with coverity static analysis
• Shah and Guyer, 2016, Iceberg a tool for static analysis of Java critical sections
• Jiang and others, 2016, JRed Program Customization and Bloatware Mitigation Based on Static Analysis
• Heo and others, 2016, Learning a Variable-Clustering Strategy for Octagon from Labeled Data Generated by a Static Analysis
• Gjomemo and others, 2016, Leveraging Static Analysis Tools for Improving Usability of Memory Error Sanitization Compilers
• Agamy and others, 2016, Model Checking Formal Verification Methodology for Virtual Channel NoCs
• Padberg and Schulz, 2016, Model Checking Reconfigurable Petri Nets with Maude
• Wang and others, 2016, On the unsoundness of static analysis for Android GUIs
• Husien and Schewe, 2016, Program Generation Using Simulated Annealing and Model Checking
• Wei and others, 2016, Revamping JavaScript static analysis via localization and remediation of root causes of imprecision
• Khamespanah and others, 2016, Schedulability Analysis of Distributed Real-Time Sensor Network Applications Using Actor-Based Model Checking
• Beyer and Dangl, 2016, SMT-based Software Model Checking An Experimental Comparison of Four Algorithms
• Horváth and Pataki, 2016, Source language representation of function summaries in static analysis
• Ouadjaout and others, 2016, Static analysis by abstract interpretation of functional properties of device drivers in TinyOS
• Journault and Miné, 2016, Static Analysis by Abstract Interpretation of the Functional Correctness of Matrix Manipulating Programs
• Barry and others, 2016, Static Analysis Numerical Algorithms
• Meurice and others, 2016, Static Analysis of Dynamic Database Usage in Java Systems
• Wu and others, 2016, Static Analysis of Runtime Errors in Interrupt-Driven Programs via Sequentialization
• Simon and Kowalewski, 2016, Static analysis of Sequential Function Charts using abstract interpretation
• Kim and others, 2016, Static Program Analysis for Identifying Energy Bugs in Graphics-Intensive Mobile Apps
• Křetínský, 2016, Survey of Statistical Verification of Linear Unbounded Properties Model Checking and Distances
• Kovács, 2016, Symbolic Computation and Automated Reasoning for Program Analysis
• Dimovski, 2016, Symbolic Game Semantics for Model Checking Program Families
• Spoto, 2016, The Julia Static Analyzer for Java
• Blazy and others, 2016, Verified Abstract Interpretation Techniques for Disassembling Low-level Self-modifying Code
• Scholz and others, 2015, A Datalog Source-to-Source Translator for Static Program Analysis An Experience Report
• Albert and others, 2015, A formal verification framework for static analysis
• Jourdan and others, 2015, A Formally-Verified C Static Analyzer
• Liu and Jin, 2015, A method to detect memory leak of C++ class field member based on static analysis
• Mattsen and others, 2015, A non-convex abstract domain for the value analysis of binaries
• Pelleau, 2015, Abstract Interpretation for the Constraints
• Kido and others, 2015, Abstract Interpretation with Infinitesimals
• Venkatasubramanyam and others, 2015, Assessing the Effectiveness of Static Analysis through Defect Correlation Analysis
• Neysian and Babamir, 2015, Automatic verification of uml state chart by bogor model checking tool Automatic formal verification of network and distributed systems
• Reps and Thakur, 2015, Automating Abstract Interpretation
• Padmanabhuni and Tan, 2015, Buffer Overflow Vulnerability Prediction from x86 Executables Using Static Analysis and Machine Learning
• Bodin and others, 2015, Certified Abstract Interpretation with Pretty-Big-Step Semantics
• Kaur and Jai, 2015, Comparing Detection Ratio of Three Static Analysis Tools
• Tóth and others, 2015, Comparison of Static Analysis Tools for Quality Measurement of RPG Programs
• Wang and others, 2015, Detecting Data Races in Interrupt-Driven Programs based on Static Analysis and Dynamic Simulation
• Ourghanlian, 2015, Evaluation of static analysis tools used to assess software important to nuclear power plant safety
• Younang and Lu, 2015, Improving Precision of Java Script Program Analysis with an Extended Domain of Intervals
• Zhang and Koutsoukos, 2015, Improving the Precision of Abstract Interpretation Based Cache Persistence Analysis
• Hübner and Peleska, 2015, Integrated Model-based Testing and Model Checking with the Benefits of Equivalence Partition Testing
• Chockler and Ruah, 2015, Lightweight Static Analysis Check of Upgrades in C/C++ Software
• Kintis and Malevris, 2015, MEDIC A static analysis framework for equivalent mutant identification
• Chaki and Karimi, 2015, Model Checking with Multi-Threaded IC3 Portfolios
• Wu and others, 2015, Numerical static analysis of interrupt-driven programs via sequentialization
• Khabibullin and others, 2015, On development of static analysis tools for string-embedded languages
• Muske and Bokil, 2015, On implementational variations in static analysis tools
• Cousot, 2015, On Various Abstract Understandings of Abstract Interpretation
• Roy and others, 2015, PAC Program Analysis for Approximation-aware Compilation
• Chaki and others, 2015, Parallel Software Model Checking
• Karpenkov and others, 2015, Program Analysis with Local Policy Iteration
• Rinetzky and Shoham, 2015, Property Directed Abstract Interpretation
• Müller and Grust, 2015, Provenance for SQL through abstract interpretation
• Urban and Miné, 2015, Proving Guarantee and Recurrence Temporal Properties by Abstract Interpretation
• Li and Feng, 2015, Quantum Markov chains Description of hybrid systems, decidability of equivalence, and model checking linear-time properties
• Midtgaard and Moller, 2015, QuickChecking Static Analysis Properties
• Dudziak, 2015, Randomized Resource-Aware Path-Sensitive Static Analysis
• Hansen and others, 2015, Semantic Importance Sampling for Statistical Model Checking
• Anderson, 2015, Software Failures Reduction with Static Analysis Tools
• Montenegro and others, 2015, Space consumption analysis by abstract interpretation Inference of recursive functions
• Montenegro and others, 2015, Space consumption analysis by abstract interpretation Reductivity properties
• 2015, Static Analysis
• Alawairdhi, 2015, Static analysis based business logic modelling from legacy system code Business process model notation BPMN extraction using abstract syntax tree AST
• Masood and Java, 2015, Static analysis for web service security - Tools and techniques for a secure development life cycle
• Zhou and Fu, 2015, Static Analysis of Memory Leak in Android Applications
• Aldous and Might, 2015, Static Analysis of Non-interference in Expressive Low-Level Languages
• Gosain and Sharma, 2015, Static Analysis A Survey of Techniques and Tools
• Shiraishi and others, 2015, Test suites for benchmarks of static analysis tools
• Hüttner and others, 2015, The efficiency of dynamic relaxation methods in static analysis of cable structures
• Miné and Delmas, 2015, Towards an industrial use of sound static analysis for the verification of concurrent embedded avionics software
• Banković and others, 2015, Trading-off Accuracy vs Energy in Multicore Processors via Evolutionary Algorithms Combining Loop Perforation and Static Analysis-Based Scheduling
• Dalla Preda and others, 2015, Unveiling metamorphism by abstract interpretation of code properties
• Cousot, 2015, Verification by abstract interpretation, soundness and abstract induction
• Jana and others, 2015, Verification of Hibernate Query Language by Abstract Interpretation
• Panichella and others, 2015, Would static analysis tools help developers with code reviews?

The bytecode layer is where this project’s bound is actually proven

Keleusma’s verifier reasons about bytecode, so the literature on what a bytecode-executing machine guarantees is directly load-bearing for Result 1. 345 contemporary records concern bytecode, virtual machines and just-in-time compilation.

• Melo and others, 2026, A Hardware Architecture for Native Execution of Python Bytecode on FPGA A Proof-of-Concept
• Pham and Nguyen‐Hai, 2026, An Approach of Structure-Enhanced Code-Centric Graph Learning for Just-in-Time Software Vulnerability Detection
• Izawa and others, 2026, Annotation-Guided Edit-Aware JIT Compilation for Julia Computational Notebooks
• Ancona and others, 2026, Assessing model-driven mutation testing of Java bytecode
• Wu and others, 2026, Designing quantum chemistry algorithms with just-in-time compilation
• Fortino and others, 2026, Detecting Ethereum Smart Contract Vulnerabilities via Bytecode Image Analysis
• Sateanpattanakul and Jetpipattanapong, 2026, Improved Control-flow Classification via Java Bytecode-Metadata
• Van and others, 2026, Just-in-Time Historical State Reconstruction for Low-Latency Financial Trading with Large Language Models
• Li and others, 2026, LuaReSym Recovering Variable Liveness Ranges in Stripped Lua Bytecode via Multi-Stage Static Analysis
• Younis, 2026, OpenQudit Extensible and Accelerated Numerical Quantum Compilation via a JIT-Compiled DSL
• Dickerson and others, 2026, Practical Python FPGA Acceleration with Fast Just-In-Time Compilation and Configuration
• Rosa and others, 2026, Seeing Through EVM Bytecode Obfuscation
• Mahale and Kawtikwar, 2026, SmartVulNet A Comparative Analysis of Deep Learning Models for Smart Contract Vulnerability Detection Using Visual Bytecode Representation
• Haindl and Kochberger, 2026, Twenty years of the Java Virtual Machine Tool Interface A systematic literature review
• Maia and others, 2026, Why Just-In-Time Compilation Matters Evaluating Runtime and Energy Efficiency
• Chen and others, 2025, An alternative to code comment generation? Generating comment from bytecode
• Vieira and others, 2025, An Interpreter-based Framework for Static Analysis of Variability in Space and Time
• Khatun and others, 2025, AndroByte LLM-Driven Privacy Analysis through Bytecode Summarization and Dynamic Dataflow Call Graph Generation
• 2025, Background on Just-in-Time Compilation
• Lanet, 2025, Bytecode Verification
• Kocourek and others, 2025, Copy-and-Patch Just-in-Time Compiler for R
• Dietrich and Hassanshahi, 2025, DALEQ - Explainable Equivalence for Java Bytecode
• Zhao and others, 2025, DEPHP A Source Code Recovery Method for PHP Bytecode with Improved Structural Analysis
• 2025, Designing Formally Verified JITs
• Su and others, 2025, DiSCo Towards Decompiling EVM Bytecode to Source Code using Large Language Models
• Goodyear and others, 2025, Early Detection of Unsupported Compilations during Prototyping in a Template-based Just-in-Time Compiler
• Iqbal and Khan, 2025, Efficient Java Bytecode Analysis and Sequence Identification for Embedded Systems
• Kumar and others, 2025, Efficient Vulnerability Detection in Solidity Ethereum Smart Contracts Through Bytecode Analysis Using Customized CNN
• Setiawan and Kusumo, 2025, Enhancing Python Object-Relational Mapping Performance using Just-in-Time Compiler
• Kaynaroglu and others, 2025, EUTROPY A Python-based software optimized with Just-In-Time compilation for simulating eutrophication dynamics in aquatic systems
• Schlägl and Groβe, 2025, Fast Interpreter-Based Instruction Set Simulation for Virtual Prototypes
• 2025, Formal Verification of a JIT Backend Compiler
• 2025, Formal Verification of Impure Coq JITs
• 2025, Formally Verified Speculative Optimizations
• Kao, 2025, From Source to Bytecode How.py Becomes.pyc
• Albert and others, 2025, Harnessing heap analysis for the synthesis of superoptimized bytecode
• Mallawarachchi and Jayaweera, 2025, Implementation of Wyltl An Imperative Language with a Dual Interpreter Compiler Architecture
• Mounesan and others, 2025, Infer-EDGE Dynamic DNN Inference Optimization in Just-in-Time Edge-AI Implementations
• Shuhao and others, 2025, Large Language Model-Guided Detection of Java Fileless Webshells via Bytecode Instrumentation
• Chukharev and others, 2025, Lookback supports semi-parallel, just-in-time processing in second language written composition
• Iqbal and Khan, 2025, Optimising Java bytecode execution performance on embedded systems using instruction set enhancement
• Kim and others, 2025, Pre-trained Models for Bytecode Instructions
• Georgakoudis and others, 2025, Proteus Portable Runtime Optimization of GPU Kernel Execution with Just-in-Time Compilation
• Qasse and others, 2025, PROXiFY A Bytecode Analysis Tool for Detecting and Classifying Proxy Contracts in Ethereum Smart Contracts
• Paganoni and Furia, 2025, Reasoning About Exceptional Behavior At the Level of Java Bytecode with ByteBack
• Herber and Weninger, 2025, Trace-Based Bytecode Interpreter Visualization for Compiler Construction Education
• Gaißert and others, 2025, Tracing Just-in-Time Compilation for Effects and Handlers
• Li and others, 2025, Two Approaches to Fast Bytecode Frontend for Static Analysis
• Marx and Erdweg, 2024, Abstract Interpretation of Java Bytecode in Sturdy
• Choi and others, 2024, Accelerating Sensor Software Performance on Edge Devices Through Just-in-Time Compilation
• Osborne and others, 2024, Awkward Just-In-Time JIT Compilation A Developer’s Experience
• Lateef and Kavitha, 2024, Blockchain Smart Contract Fortification using Bytecode Analysis to Address Vulnerabilities
• Angelo and Salzer, 2024, Bytecode Skeletons for Sample Selection in the Analysis of Blockchain Programs
• Li and Lei, 2024, Code Clone Detection Based on Bytecode and Twin Neural Networks
• Sottile and Tekriwal, 2024, Design and Implementation of a Verified Interpreter for Additive Manufacturing Programs Experience Report
• Cumming and others, 2024, EVM-Vale Formal Verification of EVM Bytecode Using Vale
• Clemente-López and others, 2024, Experimental validation of IoT image encryption scheme based on a 5-D fractional hyperchaotic system and Numba JIT compiler
• Jiang and others, 2024, JasFree Grammar-free Program Analysis for JavaScript Bytecode
• Zang and others, 2024, JOG Java JIT Peephole Optimizations and Tests from Patterns
• Houy and Bartel, 2024, Lessons Learned and Challenges of Deploying Control Flow Integrity in Complex Software the Case of OpenJDK’s Java Virtual Machine
• Bockisch and others, 2024, Mutation Testing of Java Bytecode A Model-Driven Approach
• Derlatka and others, 2024, Numba-MPI v1.0 Enabling MPI communication within Numba/LLVM JIT-compiled Python code
• Pichler and others, 2024, On Automating Hybrid Execution of Ahead-of-Time and Just-in-Time Compiled Code
• Nakamura and others, 2024, Performance Study of Kotlin and Java Programs with Bytecode Analysis
• Djoudi and others, 2024, Proof of Security Properties Application to JavaCard Virtual Machine
• Wang, 2024, Research on the Application of Smart Tourism Management System Based on Java Enterprise Edition and Ethereum Virtual Machine
• Weng and Ma, 2024, Semantic-Based Detection of Ponzi Smart Contracts Enhancing Bytecode Analysis with Source Code
• Prifti and others, 2024, Smart Contract Vulnerability Detection Using Deep Learning Algorithms on EVM bytecode
• موساوي, 2024, The roles of the interpreter in light of the Corona crisis virtual scientific conferences as a mode
• Ramesh and others, 2024, ThriveJIT Dynamic Just-In-Time Compilation for Efficient Execution of Arithmetic Expressions
• Arceri and others, 2024, Towards a Sound Construction of EVM Bytecode Control-Flow Graphs
• 2023, 4 Interpreter und Compiler
• Meng and others, 2023, A Progressive Real-Time System Performance Defect Diagnosis Framework Based on Java Virtual Machine Run-time Data
• Rosà and others, 2023, Adaptive Thread Type Selection on the Java Virtual Machine
• Ma and others, 2023, An Empirical Analysis of Just-in-Time Compilation in Modern Databases
• Verma and others, 2023, Array Bytecode Support in MicroJIT
• Pan and others, 2023, Automated Generation of Security-Centric Descriptions for Smart Contract Bytecode
• Rosà and others, 2023, Automated Runtime Transition between Virtual and Platform Threads in the Java Virtual Machine
• Lim and Debray, 2023, Automatically Localizing Dynamic Code Generation Bugs in JIT Compiler Back-End
• Lowther and others, 2023, CHERI Performance Enhancement for a Bytecode Interpreter
• Chy and others, 2023, Comparative Evaluation of Java Virtual Machine-Based Message Queue Services A Study on Kafka, Artemis, Pulsar, and RocketMQ
• Satra and others, 2023, Comparison of server technologies using Kernel-based virtual machine and container virtualization
• Chen and others, 2023, Constructing exception handling chains for testing Java virtual machine implementations
• Soto-Valero and others, 2023, Coverage-Based Debloating for Java Bytecode
• Soueidi and others, 2023, Efficient and expressive bytecode-level instrumentation for Java programs
• Schäfer and others, 2023, Finding Source Code Clones in Intermediate Representations of Java Bytecode
• Groß and others, 2023, FUZZILLI Fuzzing for JavaScript JIT Compiler Vulnerabilities
• Nair and Santha, 2023, High availability of kernel-based virtual machine using nested virtualization
• Pichler and others, 2023, Hybrid Execution Combining Ahead-of-Time and Just-in-Time Compilation
• Lee and others, 2023, Identifying Code Tampering Using A Bytecode Comparison Analysis Tool
• Li and others, 2023, Improving Precision of Detecting Deserialization Vulnerabilities with Bytecode Analysis
• Listkiewicz and others, 2023, J-Parallelio Automatic Parallelization Framework for Java Virtual Machine
• Ducasse and others, 2023, JIT Compiler Security through Low-Cost RISC-V Extension
• Bockisch and others, 2023, MMT Mutation Testing of Java Bytecode with Model Transformation
• He and others, 2023, Neural-FEBI Accurate function identification in Ethereum Virtual Machine bytecode
• Zang and others, 2023, Pattern-Based Peephole Optimizations with Java JIT Tests
• Adithia Pradana and others, 2023, Rancang Bangun Media Praktikum Mata Kuliah Sistem Operasi Dengan Kernel Virtual Machine Server Terintegrasi Dengan Sistem Akademik
• Paganoni and Furia, 2023, Reasoning About Exceptional Behavior at the Level of Java Bytecode
• Pečimúth, 2023, Remote Just-in-Time Compilation for Dynamic Languages
• Wan and others, 2023, SJBCD A Java Code Clone Detection Method Based on Bytecode Using Siamese Neural Network
• Lopes, 2023, Torchy A Tracing JIT Compiler for PyTorch
• Paganoni and Furia, 2023, Verifying Functional Correctness Properties at the Level of Java Bytecode
• Shi and others, 2022, A Bytecode-based Approach for Smart Contract Classification
• Ekici, 2022, A Sound Definitional Interpreter for a Simply Typed Functional Language
• Exelmans and others, 2022, A statecharts interpreter and compiler with semantic variability
• Basso and others, 2022, Accurate Fork-Join Profiling on the Java Virtual Machine
• Schneider and Lee, 2022, An Experimental Comparison of Clone Detection Techniques using Java Bytecode
• Rainhart and others, 2022, Analyzing the Cost of Safety for Vectorized Bytecode in Dynamically-Typed Languages
• Foroughipour and others, 2022, AndroClonium Bytecode-Level Code Clone Detection for Obfuscated Android Apps
• Kovačević and others, 2022, Automatic compiler/interpreter generation from programs for Domain-Specific Languages Code bloat problem and performance improvement
• Jain and others, 2022, Coarse Grained FPGA Overlay for Rapid Just-In-Time Accelerator Compilation
• Winkelmann and Kuchen, 2022, Constraint-logic object-oriented programming on the Java virtual machine
• Nguyen and McCaskey, 2022, Extending Python for Quantum-classical Computing via Quantum Just-in-time Compilation
• Polito and others, 2022, Interpreter Register Autolocalisation Improving the Performance of Efficient Interpreters
• Polito and others, 2022, Interpreter-guided differential JIT compiler unit testing
• Li and Ranjan, 2022, Just Enough, Just in Time, Just for “Me” Fundamental Principles for Engineering IoT-native Software Systems
• Tian and others, 2022, Just-in-Time Compilation and Link-Time Optimization for OpenMP Target Offloading
• Hartley and others, 2022, Just-In-Time Compilation on ARM-A Closer Look at Call-Site Code Consistency
• Ishimura and Yoshimoto, 2022, Just-In-Time Compiler System in Aspect-Oriented Programming based Building Block Platform for constructing Domain-Specific Language for HPC Application
• FUJIMOTO and others, 2022, KBP Kernel Enhancements for Low-Latency Networking for Virtual Machine and Container without Application Customization
• Sai and others, 2022, Machine learning-based malware detection using stacking of opcodes and bytecode sequences
• Azhar and others, 2022, PENGARUH IMPLEMENTASI KERNEL BASED VIRTUAL MACHINE PADA SERVER VPS TERHADAP PEMAKAIAN CPU MEMORY DAN HARDDISK
• Efthymiou and others, 2022, Quantum simulation with just-in-time compilation
• Chen and Zheng, 2022, Research and practice of JAVA virtual machine exception handling mechanism testing technology
• Liao and others, 2022, SmartDagger a bytecode-based static analysis approach for detecting cross-contract vulnerability
• 2022, The Compiler Backend Bytecode and Native code
• Izawa and others, 2022, Threaded Code Generation with a Meta-Tracing JIT Compiler
• Reschke and others, 2022, Toward Just-in-Time and Language-Agnostic Mutation Testing
• Wang and others, 2021, A Just-In-Time Compilation Approach for Neural Dynamics Simulation
• 2021, A Survey of Language Shaming Experiences in Interpreter Education
• Papadimitriou and others, 2021, Automatically exploiting the memory hierarchy of GPUs through just-in-time compilation
• Klein, 2021, Bytecode und Maschinencode
• Bonnaventure and others, 2021, Confuzzion A Java Virtual Machine Fuzzer for Type Confusion Vulnerabilities
• Xu and Kjolstad, 2021, Copy-and-patch compilation a fast compilation algorithm for high-level languages and bytecode
• Daoudi and others, 2021, DexRay A Simple, yet Effective Deep Learning Approach to Android Malware Detection Based on Image Representation of Bytecode
• Djoudi and others, 2021, Formal Verification of a JavaCard Virtual Machine with Frama-C
• Barrière and others, 2021, Formally verified speculation and deoptimization in a JIT compiler
• Sateanpattanakul and others, 2021, Java Bytecode Control Flow Classification Framework for Guiding Java Decompilation
• Engebreth, 2021, JIT Compiler
• Bazai and others, 2021, Kernel Virtual Machine based High Performance Environment for Grid and Jungle Computing
• Canales and others, 2021, Optimization of Java Virtual Machine Flags using Feature Model and Genetic Algorithm
• Schwarz and Hochberger, 2021, Performance Gain of a Data Flow Oriented ISA as Replacement for Java Bytecode
• Sonoyama and others, 2021, Performance Study of Kotlin and Java Program Considering Bytecode Instructions and JVM JIT Compiler
• Crosara and others, 2021, Re-engineering ERC-20 Smart Contracts with Efficient Snapshots for the Java Virtual Machine
• Schafer and others, 2021, Stubber Compiling Source Code into Bytecode without Dependencies for Java Code Clone Detection
• Kiepas and others, 2021, Using Performance Event Profiles to Deduce an Execution Model of MATLAB with Just-In-Time Compilation
• Wu and others, 2021, When Program Analysis Meets Bytecode Search Targeted and Efficient Inter-procedural Analysis of Modern Android Apps in BackDroid
• Rosà and Binder, 2020, P ^ 3 A Profiler Suite for Parallel Applications on the Java Virtual Machine
• Andrey and Pavel, 2020, A Technique for Analyzing Bytecode in a Java Project for the Purpose of an Automated Assessment of the Possibility and Effectiveness of the Hidden Investment of Information and its Volumes in a Java Project
• Pufek and others, 2020, Achieving Efficient Structured Concurrency through Lightweight Fibers in Java Virtual Machine
• Lee and others, 2020, An efficient garbage collection in java virtual machine via swap I/O optimization
• Soueidi and others, 2020, BISM Bytecode-Level Instrumentation for Software Monitoring
• Hu and others, 2020, DexFus An Android Obfuscation Technique Based on Dalvik Bytecode Translation
• Maejima and others, 2020, Does This Code Change Affect Program Behavior? Identifying Nonbehavioral Changes with Bytecode
• Park and Ryu, 2020, EVM Bytecode Analysis Using an Abstract-Index-Based Memory Analysis Technique
• Ferrara and others, 2020, From CIL to Java bytecode Semantics-based translation for static analysis leveraging
• Zeng and others, 2020, FVIL Intermediate Language Based on Formal Verification Virtual Machine
• Keirsgieter and Visser, 2020, Graft Static Analysis of Java Bytecode with Graph Databases
• Paul and others, 2020, Improving execution efficiency of just-in-time compilation based query processing on GPUs
• Ke and Chen, 2020, Instruction Verification of Ethereum Virtual Machine by Formal Method
• Shibata and others, 2020, Java Android Application Performance Improvement by Kotlin DEX Bytecode Analysis without JIT Compiler
• Bockisch and others, 2020, Java Bytecode Verification with OCL Why, How and Whenc
• Brennan and others, 2020, JIT Leaks Inducing Timing Side Channels through Just-In-Time Compilation
• Daoud and Dagenais, 2020, Multilevel analysis of the java virtual machine based on kernel and userspace traces
• Buszewicz, 2020, Performance analysis of languages working on Java Virtual Machine based on Java, Scala and Kotlin
• Rosero and others, 2020, Profiling streams on the Java virtual machine
• Dobravec, 2020, Selected tools for Java class and bytecode inspection in the educational environment
• Van Geffen and others, 2020, Synthesizing JIT Compilers for In-Kernel DSLs
• Tine and others, 2020, Tango An Optimizing Compiler for Just-In-Time RTL Simulation
• Macias and others, 2020, WebJShrink a web service for debloating Java bytecode
• Dageförde and Kuchen, 2019, A compiler and virtual machine for constraint-logic object-oriented programming with Muli
• Zhan and others, 2019, A Low-Overhead Kernel Object Monitoring Approach for Virtual Machine Introspection
• Kopeć and Smołka, 2019, A performance comparison of garbage collector algorithms in Java Virtual Machine
• Niyizamwiyitira and Lundberg, 2019, A Utilization-Based Schedulability Test of Real-Time Systems Running on a Multiprocessor Virtual Machine
• Peng and others, 2019, An Adaptive Approach to Recommending Obfuscation Rules for Java Bytecode Obfuscators
• Rosà and others, 2019, Analysis and Optimization of Task Granularity on the Java Virtual Machine
• Hajmasan and others, 2019, Bytecode Heuristic Signatures for Detecting Malware Behavior
• Finkel and others, 2019, ClangJIT Enhancing C++ with Just-in-Time Compilation
• Nguyen and others, 2019, Code Search on Bytecode for Mobile App Development
• Choi and Hong, 2019, Design and implementation of virtual machine control and streaming scheme using Linux kernel-based virtual machine hypercall for virtual mobile infrastructure
• Celik and others, 2019, Design, implementation, and application of GPU-based Java bytecode interpreters
• Yu and others, 2019, Detecting Java Code Clones Based on Bytecode Sequence Alignment
• Yasugi and others, 2019, Evaluating Portable Mechanisms for Legitimate Execution Stack Access with a Scheme Interpreter in an Extended SC Language
• HATABA and others, 2019, Generation of Efficient Obfuscated Code through Just-in-Time Compilation
• Huang and others, 2019, Improving Sequential Performance of Erlang Based on a Meta-tracing Just-In-Time Compiler
• Dobravec, 2019, Java Virtual Machine Educational Tools
• Cordeiro and others, 2019, JBMC Bounded Model Checking for Java Bytecode
• Schkufza and others, 2019, Just-In-Time Compilation for Verilog
• Pomonis and others, 2019, Kernel Protection Against Just-In-Time Code Reuse
• Pantilimonov and others, 2019, Machine Code Caching in PostgreSQL Query JIT-Compiler
• Na and others, 2019, Mobile Code Anti-Reversing Scheme Based on Bytecode Trapping in ART
• Rosales and others, 2019, Optimization coaching for fork/join applications on the Java virtual machine
• Perez and others, 2019, Orthogonal persistence in nonvolatile memory architectures A persistent heap design and its implementation for a Java Virtual Machine
• Mukmin and Cholil, 2019, PERBANDINGAN OPENVZ DENGAN KERNEL BASED VIRTUAL MACHINE KVM
• Tine and others, 2019, POSTER Tango An Optimizing Compiler for Just-In-Time RTL Simulation
• Ghanbari and others, 2019, Practical program repair via bytecode mutation
• Ghanbari and Zhang, 2019, PraPR Practical Program Repair via Bytecode Mutation
• Zhang and others, 2019, Refactoring Java Programs for Customizable Locks Based on Bytecode Transformation
• Cabrera Arteaga and others, 2019, Scalable comparison of JavaScript V8 bytecode traces
• Ayoade and others, 2019, Smart Contract Defense through Bytecode Rewriting
• Zhang and others, 2019, SNC A Cloud Service Platform for Symbolic-Numeric Computation Using Just-In-Time Compilation
• Geraldo and Costa Seco, 2019, SNITCH Dynamic Dependent Information Flow Analysis for Independent Java Bytecode
• Dann and others, 2019, SootDiff bytecode comparison across different Java compilers
• Harrand and others, 2019, The Strengths and Behavioral Quirks of Java Bytecode Decompilers
• Tinnerholm and others, 2019, Towards introducing just-in-time compilation in a Modelica compiler
• Moliavko and others, 2019, uJVM Lightweight Java Virtual Machine for embedded systems
• Pizzolotto and Ceccato, 2018, Research Paper Obfuscating Java Programs by Translating Selected Portions of Bytecode to Native Libraries
• Kumar and Kaur, 2018, A Comparative Analysis of Static and Dynamic Java Bytecode Watermarking Algorithms
• Achour and others, 2018, A Constraint-Based Verification Approach for Java Bytecode Programs
• Vandercammen and others, 2018, A flexible framework for studying trace-based just-in-time compilation
• Park and others, 2018, A formal verification tool for Ethereum VM bytecode
• Soomro and others, 2018, A Framework for Debugging Java Programs in a Bytecode
• Czarnik and others, 2018, A Java Bytecode Formalisation
• Yildiz and others, 2018, A Java Bytecode Metamodel for Composable Program Analyses
• Hong and others, 2018, A Java Card Virtual Machine Design Based on Off-card/On-card Co-design Pre-processing
• Wang and others, 2018, A low-overhead and efficient Java object profiler on ART virtual machine
• Achour, 2018, A Model Based Testing Approach for Java Bytecode Programs
• Kim and Lee, 2018, A Study on the Code Generator for a Virtual Machine Code based JavaScript Compiler
• Hamann and others, 2018, A Uniform Information-Flow Security Benchmark Suite for Source Code and Bytecode
• Lukács and Tóth, 2018, Analysis of Erlang source dependencies in BEAM bytecode
• Vu and Haffari, 2018, Automatic Post-Editing of Machine Translation A Neural Programmer-Interpreter Approach
• Ferrara and others, 2018, CIL to Java-bytecode translation for static analysis leveraging
• Achour and Benattou, 2018, Constraint Based Testing and Verification of Java Bytecode Programs
• Strug and Strug, 2018, Cost Reduction in Mutation Testing with Bytecode-Level Mutants Classification
• Laneve and Garcia, 2018, Deadlock Detection of Java Bytecode
• Ning and Zhang, 2018, DexLego Reassembleable Bytecode Extraction for Aiding Static Analysis
• Caamaño and Guelton, 2018, Easy Jit compiler assisted library to enable just-in-time compilation in C++ codes
• Feng and others, 2018, Eliminating object reference checks by escape analysis on real-time Java virtual machine
• Kuang and others, 2018, Enhance virtual-machine-based code obfuscation security through dynamic bytecode scheduling
• Albert and others, 2018, EthIR A Framework for High-Level Analysis of Ethereum Bytecode
• Ahmad and Shareef, 2018, Hands-On Kernel-Based Virtual Machine KVM
• Ottoni, 2018, HHVM JIT a profile-guided, region-based compiler for PHP and Hack
• Dobravec, 2018, JAVA BYTECODE INSTRUCTION USAGE COUNTING WITH ALGATOR
• Cordeiro and others, 2018, JBMC A Bounded Model Checking Tool for Verifying Java Bytecode
• Brock and others, 2018, PAYJIT space-optimal JIT compilation and its practical implementation
• Kume and others, 2018, Revealing Implicit Correspondence between Bytecode Instructions and Expressions Determined by Java Compilers
• Ziadi and Hillah, 2018, Software Product Line Extraction from Bytecode Based Applications
• Inafune and others, 2018, Symbolic backward simulation of Java bytecode program
• Madsen and others, 2018, Tail call elimination and data representation for functional languages on the Java virtual machine
• Kwon and others, 2018, VM-CFI Control-Flow Integrity for Virtual Machine Kernel Using Intel PT
• Achour and Benattou, 2018, Vulnerabilities Constraint Based Analysis Approach for Java Bytecode Programs
• Jeannerod and others, 2017, A Formally Verified Interpreter for a Shell-Like Programming Language
• Pape and others, 2017, Adaptive just-in-time value class optimization for lowering memory consumption and improving execution time performance
• Baxter and Cavalcanti, 2017, Algebraic Compilation of Safety-Critical Java Bytecode
• Kostelansky and Dedera, 2017, An evaluation of output from current Java bytecode decompilers Is it Android which is responsible for such quality boost?
• Catal and others, 2017, Automatic Software Categorization Using Ensemble Methods and Bytecode Analysis
• Klein, 2017, Bytecode und Maschinencode
• Zhan and others, 2017, Checking virtual machine kernel control-flow integrity using a page-level dynamic tracing approach
• Horváth and others, 2017, Code coverage differences of Java bytecode and source code instrumentation tools
• Son and others, 2017, Design and Implementation of the RSIL to LLVM IR Translator for Verification of the Intermediate Code on IoT Virtual Machine
• Lee and others, 2017, Design and implementation of the secure compiler and virtual machine for developing secure IoT services
• Yu and others, 2017, Detecting Java Code Clones with Multi-granularities Based on Bytecode
• Zhao and others, 2017, DexPro A Bytecode Level Code Protection System for Android Applications
• Pracner and Budimac, 2017, Enabling code transformations with FermaT on simplified bytecode
• Dobravec, 2017, Estimating the time complexity of the algorithms by counting the Java bytecode instructions
• Rohr and Lindenstruth, 2017, Fast Failure Erasure Encoding Using Just in Time Compilation for CPUs, GPUs, and FPGAs
• Fumero and others, 2017, Just-In-Time GPU Compilation for Interpreted Languages with Partial Evaluation
• Hebbal and others, 2017, K-binID Kernel binary code identification for Virtual Machine Introspection
• Rigger and others, 2017, Lenient Execution of C on a Java Virtual Machine
• Lee and others, 2017, NCU-HA A Lightweight HA System for Kernel-Based Virtual Machine
• Yeboah-Antwi and Baudry, 2017, Online genetic improvement on the java virtual machine with ECSELR
• Soomro and others, 2017, Path Executions of Java Bytecode Programs
• Ganesan and others, 2017, Scaling the Java Virtual Machine on a Many-Core System
• Sharygin and Buchatskiy, 2017, Survey of Just-in-Time Query Compilation Methods
• Rosales and others, 2017, tgp A Task-Granularity Profiler for the Java Virtual Machine
• Muhammad and others, 2017, Visualizing trace of Java collection APIs by dynamic bytecode instrumentation
• Wang and others, 2017, YA-JOP Yet Another Java Object Profiler On Art Virtual Machine
• Lee and others, 2016, A JIT Compilation-Based Unified SQL Query Optimization System
• Son and Lee, 2016, A Study on the Interpreter for the Light-Weighted Virtual Machine on IoT Environments
• Haase, 2016, Abstract Interpretation of Java Bytecode for Immutability Analysis
• Rosà and others, 2016, Adaptable Runtime Monitoring for the Java Virtual Machine
• Janik and Krawczyk, 2016, AJVM JAVA Virtual Machine Implemented in Actionscript 3.0
• Dissegna and others, 2016, An Abstract Interpretation-Based Model of Tracing Just-in-Time Compilation
• Kumar and others, 2016, An Evaluation of Dynamic Java Bytecode Software Watermarking Algorithms
• Bulej and others, 2016, Beneath the bytecode
• Zakkak and Pratikakis, 2016, Building a Java™ Virtual Machine for Non-Cache-Coherent Many-core Architectures
• Briggs and others, 2016, Cold object identification in the Java virtual machine
• Martinsen and others, 2016, Combining thread-level speculation and just-in-time compilation in Google’s V8 JavaScript engine
• Backes and others, 2016, Computational Soundness for Dalvik Bytecode
• Nanda and Arun-Kumar, 2016, Decompiling Boolean Expressions from Java™ Bytecode
• Karnalim, 2016, Detecting source code plagiarism on introductory programming course assignments using a bytecode approach
• Hofer and others, 2016, Efficient Tracing and Versatile Analysis of Lock Contention in Java Applications on the Virtual Machine Level
• Cheng and others, 2016, Formalised EMFTVM bytecode language for sound verification of model transformations
• Luckow and others, 2016, HVM TP A time predictable and portable java virtual machine for hard real-time embedded systems
• Xiao and others, 2016, HyperLink Virtual Machine Introspection and Memory Forensic Analysis without Kernel Source Code
• Alam and others, 2016, J-Viz Finding algorithmic complexity attacks via graph visualization of Java bytecode
• Lancia and Bouffard, 2016, Java Card Virtual Machine Compromising from a Bytecode Verified Applet
• Ren and Foster, 2016, Just-in-time static type checking for dynamic languages
• Yongjin Park and others, 2016, Mobile Code Packing Scheme Based on Multi-partitioned Bytecode Wrapping
• Tengeri and others, 2016, Negative Effects of Bytecode Instrumentation on Java Source Code Coverage
• CLERC, 2016, OCaml-Java The Java Virtual Machine as the target of an OCaml compiler
• Yeboah-Antwi and Baudry, 2016, Online Genetic Improvement on the java virtual machine with ECSELR
• Choi and Lee, 2016, Optimizing Constant Value Generation in Just-in-time Compiler for 64-bit JavaScript Engine
• Hema and others, 2016, Performance Analysis of Java Virtual Machine for Machine Learning Workloads using Apache Spark
• Béra and others, 2016, Practical Validation of Bytecode to Bytecode JIT Compiler Dynamic Deoptimization
• Haidl Michael and others, 2016, Programming GPUs with C++14 and Just-In-Time Compilation
• Cho and others, 2016, Runtime Input Validation for Java Web Applications using Static Bytecode Instrumentation
• Aciu and Ciocarlie, 2016, Runtime Translation of the Java Bytecode to OpenCL and GPU Execution of the Resulted Code
• Nadkarni and others, 2016, Semi natural language algorithm to programming language interpreter
• Kim and others, 2016, Short-Circuit Dispatch Accelerating Virtual Machine Interpreters on Embedded Processors
• Achour and Benattou, 2016, Test case generation for Java Bytecode programs annotated with BML specifications
• Li, 2016, Test of Exception Handling in Different Java Virtual Machine
• Gotti and Mbarki, 2016, Toward IFVM Virtual Machine A Model Driven IFML Interpretation
• Eisl and others, 2016, Trace-based Register Allocation in a JIT Compiler
• Gregor and Spalek, 2016, Using LLVM-based JIT compilation in genetic programming
• Plangger and Krall, 2016, Vectorization in PyPy’s Tracing Just-In-Time Compiler
• Seitzer and others, 2015, A Bytecode Interpreter for Secure Program Execution in Untrusted Main Memory
• Malik, 2015, Accessing Swift’s Compiler and Interpreter REPL
• Pape and others, 2015, Adaptive just-in-time value class optimization
• Vasudevan and others, 2015, An Architecture of Class Loader System in Java Bytecode Obfuscation
• Vartanov and Ermakov, 2015, Applying Java bytecode static instrumentation for software dynamic analysis
• Zhuykov and others, 2015, Augmenting JavaScript JIT with ahead-of-time compilation
• Jayasena and others, 2015, Auto-Tuning the Java Virtual Machine
• Munjal and others, 2015, Automated Slicing of Aspect-Oriented Programs Using Bytecode Analysis
• Escobar-Avila, 2015, Automatic Categorization of Software Libraries Using Bytecode
• Nanthaamornphong and others, 2015, Bytecode-based class dependency extraction tool Bytecode-CDET
• Oh and others, 2015, Bytecode-to-C Ahead-of-Time Compilation for Android Dalvik Virtual Machine
• Umatani and others, 2015, Design and Implementation of a Java Bytecode Manipulation Library for Clojure
• Ermakov and Vartanov, 2015, Dynamic Java program analysis using virtual machine modification
• Upadhyaya and Rajan, 2015, Effectively mapping linguistic abstractions for message-passing concurrency to threads on the Java virtual machine
• Bond and others, 2015, Efficient Deterministic Replay of Multithreaded Executions in a Managed Language Virtual Machine
• Huang and others, 2015, Exploration of the Relationship Between Just-in-Time Compilation Policy and Number of Cores
• Fujiwara and others, 2015, Fault-Prone Byte-Code Detection Using Text Classifier
• Gunadi, 2015, Formal Certification of Non-interferent Android Bytecode DEX Bytecode
• Akeret and others, 2015, HOPE A Python just-in-time compiler for astrophysical computations
• Gad and others, 2015, Improving network traffic acquisition and processing with the Java Virtual Machine
• Ahmed and others, 2015, Integrity Checking of Function Pointers in Kernel Pools via Virtual Machine Introspection
• Davi and others, 2015, Isomeron Code Randomization Resilient to Just-In-Time Return-Oriented Programming
• Manchana, 2015, Java Virtual Machine JVM Architecture, Goals, and Tuning Options
• Fischer, 2015, Lambdas in Java Bytecode
• Myalapalli and Geloth, 2015, Minimizing impact on JAVA virtual machine via JAVA code optimization
• Hamza and others, 2015, On the Design of a Java Virtual Machine for Mixed-criticality Systems
• Widemann and Lepper, 2015, On-Line Synchronous Total Purely Functional Data-Flow Programming on the Java Virtual Machine with Sig
• Feng and others, 2015, Optimizing object reference checks on real-time Java virtual machine
• 2015, Optimizing Web Application’s Execution Time By Caching PHP ByteCode Using Zend OPCache
• Hewson and others, 2015, Performance Regression Testing on the Java Virtual Machine Using Statistical Test Oracles
• Amighi and others, 2015, Provably correct control flow graphs from Java bytecode programs with exceptions
• Kasmi and others, 2015, Reversing Bytecode of Obfuscated Java Based Smart Card Using Side Chanel Analysis
• Koomsin and Shinjo, 2015, Running application specific kernel code by a just-in-time compiler
• Baxter and others, 2015, Safety-Critical Java Virtual Machine Services
• Weißer and others, 2015, Security Analysis of PHP Bytecode Protection Mechanisms
• Santhi and others, 2015, The Simian concept Parallel Discrete Event Simulation with interpreted languages and just-in-time compilation
• Lantz and Johansson, 2015, Towards bridging the gap between Dalvik bytecode and native code during static analysis of Android applications
• Escobar-Avila and others, 2015, Unsupervised Software Categorization Using Bytecode
• Clarke and others, 2015, Using “must” and “may” summaries to detect data races in Java bytecode that does not rely on the synchronized construct

Stack and memory bounds computed on the artefact

The 155 records here compute a bound on the thing that runs instead of on a model of it, which is the move this article concludes the project must make.

• Julianti and others, 2026, Analysis Of Cpu And Memory Usage In Monitoring-Based Operating Systems Using Python
• Nguyen and others, 2026, Analyzing Bytes Pre-Disassembly Static Binary Analysis
• Sapkale and others, 2026, Automating Tag Prediction in Stack Overflow Using Machine Learning and Deep Learning Techniques
• Liu and others, 2026, BIT Empowering Binary Analysis through the LLVM Toolchain
• Zhou and others, 2026, Evaluating subsea-capping-stack usage for CO2 blowouts
• Mani, 2026, Machine Learning-Based Prediction of MRP Process Runtime and Memory Usage for Scalable Business Operations
• Centeno and others, 2026, Sensitivity Analysis of Fractional Linear Systems Based on Random Walks with Negligible Memory Usage
• Djalali and others, 2026, Understanding Developer Misconceptions Between Accessibility and Usability An Empirical Study on Stack Overflow
• Borwankar and others, 2026, Unraveling the Impact An Empirical Investigation of ChatGPT’s Exclusion from Stack Overflow
• Licorish and others, 2026, Why Do You Contribute to Stack Overflow? Insights for Sustaining Knowledge Ecosystems in the Age of LLMs
• Zolduoarrati and others, 2025, A cross-continental analysis of how regional cues shape top stack overflow contributors
• Moussaoui and others, 2025, Bin2Vec Interpretable and Auditable Multi-View Binary Analysis for Code Plagiarism Detection
• Zhang and others, 2025, CARLDA An Approach for Stack Overflow API Mention Recognition Driven by Context and LLM-Based Data Augmentation
• Bregolin, 2025, Communication Quality and the Cost of Language Evidence from Stack Overflow
• Helbling and others, 2025, cozy Comparative Symbolic Execution for Binary Programs
• Petingola, 2025, Deep Learning-based Binary Analysis for Vulnerability Detection in x86-64 Machine Code
• M Jain and Ayush Jain, 2025, Ensemble Time Series Modeling for High Precision Cloud Memory Usage Prediction
• Kavargyris and others, 2025, ESCOPlus A Framework for Enriching the ESCO Taxonomy with Digital Skills from Stack Overflow
• Popof and Illés, 2025, Impact of Artificial Intelligence on Programmers’ Willingness and Ability to Learn-Based on Stack Overflow Data from 2023 to 2024
• Little and Xu, 2025, Inspecting Compiler Optimizations on Mixed Boolean Arithmetic Obfuscation
• Da Silva and others, 2025, LLMs and Stack Overflow discussions Reliability, impact, and challenges
• Zhai and others, 2025, Stack overflow vulnerability detection based on BiLSTM-attention KAN deep learning model
• Carpenter, 2025, Subsea Capping-Stack Usage Evaluated for CO2 Blowouts
• Xia and others, 2025, SYNCode Synergistic Human-LLM Collaboration for Enhanced Data Annotation in Stack Overflow
• Okpanachi and others, 2025, Temporal Analysis of User Engagement, Technology Trends and Emotional Dynamics on Stack Overflow
• Althobaiti and Tahaei, 2025, Understanding phishing discussions on stack overflow and information security stack exchange
• Huang and Chattopadhyay, 2024, A Tale of Two Communities Exploring Academic References on Stack Overflow
• Chen and others, 2024, An empirical study of code reuse between GitHub and stack overflow during software development
• Raghuwanshi and others, 2024, Automated Categorization of Stack Overflow Queries Solution to Highlight the Similar Kind of Queries
• Beau and Crabbé, 2024, CodeInsight A Curated Dataset of Practical Coding Solutions from Stack Overflow
• Yeon Kim and others, 2024, Comparison of AI Model Serving Efficiency Response Time and Memory Usage Analysis
• Zhou and others, 2024, Evaluating Subsea Capping Stack Usage for CO2 Blowouts
• AlOmar and others, 2024, How Is Software Reuse Discussed in Stack Overflow?
• Chen and others, 2024, Identifying Smart Contract Security Issues in Code Snippets from Stack Overflow
• Temizkan and Kumar, 2024, Knowledge transfer to aid social coding The case of Stack Overflow
• Gong and Zhang, 2024, MR2-KG A Multi-Relation Multi-Rationale Knowledge Graph for Modeling Software Engineering Knowledge on Stack Overflow
• Zhu and Yang, 2024, Predicting CPU and Memory Usage in Code Execution Using Machine Learning Models
• Su and others, 2024, Source Code Foundation Models are Transferable Binary Analysis Knowledge Bases
• Chen and others, 2024, Studying Versioning in Stack Overflow
• Giwangkoro and Nugroho, 2024, Unveiling Research Trends in Stack Overflow A Comprehensive Analysis of General Discussion Theme
• McKee and others, 2023, Accurate Compiler and Optimization Independent Function Identification Using Program State Transformations
• Bucha and Gupta, 2023, Code Generation - Leveraging Stack Overflow and GitHub Gists for Enhanced Training
• Tomiyama and others, 2023, Dynamic Analysis for Malware Detection Using API Calls and Memory Usage With Machine Learning Approach
• Shan and Qiu, 2023, Examining the Impact of Generative AI on Users’ Voluntary Knowledge Contribution Evidence from A Natural Experiment on Stack Overflow
• Zhang and others, 2023, Fine-Grained Modeling of ROP Vulnerability Exploitation Process under Stack Overflow Based on Petri Nets
• Mondal and others, 2023, Investigating Technology Usage Span by Analyzing Users’ QandA Traces in Stack Overflow
• Kovács and Vastag, 2023, Magyar szoftverfejlesztők bérkülönbségeinek elemzése a Stack Overflow kérdőíve alapján
• Newaz and Mollah, 2023, Memory Usage Prediction of HPC Workloads Using Feature Engineering and Machine Learning
• Marcovich and others, 2023, PISE Protocol Inference using Symbolic Execution and Automata Learning
• Khan and others, 2023, Stack Overflow Data Warehouse System
• Guven and Uysal, 2023, Time Series Forecasting Performance of the Novel Deep Learning Algorithms on Stack Overflow Website Data
• Brooke, 2023, Trouble in programmer’s paradise gender-biases in sharing and recognising technical knowledge on Stack Overflow
• Al Shoaibi and Mkaouer, 2023, Understanding Software Performance Challenges an Empirical Study on Stack Overflow
• ISLAM and others, 2022, An Exploration of npm Package Co-Usage Examples from Stack Overflow A Case Study
• Rahman and Roy, 2022, An Insight into the Reusability of Stack Overflow Code Fragments in Mobile Applications
• Alshannaq and others, 2022, Analysis of the Lowest Memory Consumption Memory Usage Through Running Different Cryptography Techniques for Different Types of Images
• Mondal and others, 2022, Automatic prediction of rejected edits in Stack Overflow
• Baltes and others, 2022, Contextual Documentation Referencing on Stack Overflow
• Battle and others, 2022, Exploring D3 Implementation Challenges on Stack Overflow
• Ngaogate, 2022, Memory Usage Comparison in an Android Application Basic Object-Oriented Programming vs Decorator Design Pattern
• Fu and others, 2022, Patterns of interest change in stack overflow
• Oliveira and others, 2022, Ten Years of eHealth Discussions on Stack Overflow
• Velazquez-Rodriguez and others, 2022, Uncovering Library Features from API Usage on Stack Overflow
• Tahaei and others, 2022, Understanding Privacy-Related Advice on Stack Overflow
• Namboodiri and others, 2021, An Experimental Stack Overflow Chatbot Architecture Using NLP Techniques
• Park and others, 2021, Automated Memory Corruption Detection through Analysis of Static Variables and Dynamic Memory Usage
• Suwonchoochit and Senivongse, 2021, Classification of Database Technology Problems on Stack Overflow
• Luong and others, 2021, Disambiguating Mentions of API Methods in Stack Overflow via Type Scoping
• Tempel and others, 2021, In-Vivo Stack Overflow Detection and Stack Size Estimation for Low-End Multithreaded Operating Systems using Virtual Prototypes
• Wu and others, 2021, Leveraging Stack Overflow to Detect Relevant Tutorial Fragments of APIs
• Naghshzan and others, 2021, Leveraging Unsupervised Learning to Summarize APIs Discussed in Stack Overflow
• Morin and Ghosh, 2021, Linguistic Analysis of Stack Overflow Data Native English vs Non-native English Speakers
• Choi and others, 2021, NtFuzz Enabling Type-Aware Kernel Fuzzing on Windows with Static Binary Analysis
• Costa and others, 2021, On the relation between technical debt indicators and quality criteria in Stack Overflow discussions
• Oliveira and others, 2021, Software Development During COVID-19 Pandemic an Analysis of Stack Overflow and GitHub
• Wang and others, 2021, SONAS A System to Obtain Insights on Web APIs from Stack Overflow
• Zhang and others, 2020, A Static Method for Stack Overflow Detection Based on SPARC V8 Architecture
• Kumar, 2020, Analysis of Stack Overflow Data using Web Portal
• Rausanfita and Rochimah, 2020, Automated Identification and Classification of Usability Aspect of Stack Overflow Constraints
• Pan and others, 2020, BAHK Flexible Automated Binary Analysis Method with the Assistance of Hardware and System Kernel
• Alrabaee and others, 2020, Binary Analysis Overview
• Beckman and Haile, 2020, Binary Analysis with Architecture and Code Section Detection using Supervised Machine Learning
• Cabrera-Diego and others, 2020, Classifying emotions in Stack Overflow and JIRA using a multi-label approach
• Baltes and Treude, 2020, Code duplication on stack overflow
• Amon and Loffredo, 2020, Creating Human Readable Path Constraints from Symbolic Execution
• Cagnoni and others, 2020, Emotion-based analysis of programming languages on Stack Overflow
• Iqbal and others, 2020, ERF An Empirical Recommender Framework for Ascertaining Appropriate Learning Materials from Stack Overflow Discussions
• Busch and Dirsch, 2020, Finding 1-Day Vulnerabilities in Trusted Applications using Selective Symbolic Execution
• ŞAHİN and GÜLER BAYAZIT, 2020, Java Geliştiricileri Stack Overflow Üzerinde Ne Hakkında Konuşuyor? Deneysel Bir Çalışma
• Rodwald, 2020, Large Scale Attack on Gravatars from Stack Overflow
• Otsubo and others, 2020, o-glassesX Compiler Provenance Recovery with Attention Mechanism from a Short Code Fragment
• Chinnakali and others, 2020, Organising the knowledge from stack overflow about location-sensing of Android applications
• Xu and others, 2020, What Makes Geeks Tick? A Study of Stack Overflow Careers
• Nishi and others, 2019, Characterizing Duplicate Code Snippets between Stack Overflow and Tutorials
• Kariri and Rodríguez, 2019, e-mentoring Activities in Online Programming Communities An Empirical Study on Stack Overflow
• Tian and others, 2019, Geek Talents Who are the Top Experts on GitHub and Stack Overflow?
• May and others, 2019, Gender differences in participation and reward on Stack Overflow
• 2019, Named Entity Recognition Supporting Serious Games Development in Stack Overflow Social Content
• Treude and Wagner, 2019, Predicting Good Configurations for GitHub and Stack Overflow Topic Models
• Ellmann, 2019, Same-Same But Different On Understanding Duplicates in Stack Overflow
• Kim and Ryou, 2019, Source Code Analysis for Static Prediction of Dynamic Memory Usage
• Hakert and others, 2019, Stack Usage Analysis for Efficient Wear Leveling in Non-Volatile Main Memory Systems
• Machiry and others, 2019, Towards Automatically Generating a Sound and Complete Dataset for Evaluating Static Analysis Tools
• Sharma and Sodhi, 2019, Using Stack Overflow content to assist in code review
• Fan and others, 2019, Why do they ask? An exploratory study of crowd discussions about Android application programming interface in stack overflow
• Brooke, 2019, “Condescending, Rude, Assholes” Framing gender and hostility on Stack Overflow
• Zhang and Deng, 2018, A Depth Variant Seismic Wavelets Extraction Method for Inversion of Post-Stack Depth Domain Seismic Data
• Novielli and others, 2018, A gold standard for emotion annotation in stack overflow
• Shao and Sun, 2018, A Recommendation Service for Programming Study Based on Stack Overflow
• Huang and others, 2018, Automatic Detection of Stack Overflow Attack in Canary
• Sumanth and K, 2018, Discovering Top Experts for Trending Domains on Stack Overflow
• Ban and others, 2018, Identifying Potential Experts on Stack Overflow
• Park and others, 2018, Memory corruption detecting method using static variables and dynamic memory usage
• Salleh and others, 2018, Preventing Stack Overflow Using Alternative Stack Approaches
• Ellmann and Schnecke, 2018, Two perspectives on software documentation quality in stack overflow
• Wang, 2018, Understanding the Reputation Differences between Women and Men on Stack Overflow
• Feng and Zhang, 2017, A Static Taint Detection Method for Stack Overflow Vulnerabilities in Binaries
• Turner and McIntosh-Smith, 2017, A Survey of Application Memory Usage on a National Supercomputer An Analysis of Memory Requirements on ARCHER
• Attiaoui and others, 2017, Belief Temporal Analysis of Expert Users Case Study Stack Overflow
• Rao and Rao, 2017, HDFS memory usage analysis
• Choi and others, 2017, Maximum Stack Memory Monitoring Method Assisted by Static Analysis of the Stack Usage Profile
• Neshati, 2017, On early detection of high voted QandA on Stack Overflow
• Krishnaraj and others, 2017, Performance of procedures for identifying influentials in a social network prediction of time and memory usage as a function of network properties
• Fumin and others, 2017, Recommendflow Use Topic Model to Automatically Recommend Stack Overflow QandA in IDE
• An and others, 2017, Stack Overflow A code laundering platform?
• Weng and others, 2017, Static techniques for reducing memory usage in the C implementation of whiley programs
• Mizobuchi and Takayama, 2017, Two improvements to detect duplicates in Stack Overflow
• Treude and Robillard, 2017, Understanding Stack Overflow Code Fragments
• Lee and others, 2017, Understanding User’s Interests in NoSQL Databases in Stack Overflow
• Ford, 2017, Using eye tracking to identify features of peer parity on stack overflow
• Oktavianita and others, 2016, An Analysis of Memory Usage in Web Browser Software
• Sahu and others, 2016, An Empirical Analysis on Reducing Open Source Software Development Tasks using Stack Overflow
• Treude and Robillard, 2016, Augmenting API documentation with insights from stack overflow
• Rocha and Maia, 2016, Automated API Documentation with Tutorials Generated From Stack Overflow
• Vigna, 2016, Binary Analysis for Autonomous Hacking
• Alrabaee and others, 2016, BinGold Towards robust binary analysis by extracting the semantics of binary code as semantic flow graphs SFGs
• Zhou and Fong, 2016, Exploring the Feature Selection-Based Data Analytics Solutions for Text Mining Online Communities by Investigating the Influential Factors A Case Study of Programming CQA in Stack Overflow
• Beyer and Pinzger, 2016, Grouping android tag synonyms on stack overflow
• Tavakoli and others, 2016, Improving the quality of code snippets in stack overflow
• Hatvani and Bril, 2016, Minimizing stack usage for AUTOSAR/OSEK’s restricted fixed-priority preemption threshold support
• Ford, 2016, Recognizing gender differences in stack overflow usage Applying the Bechdel test
• Stoenescu and others, 2016, RIVER A Binary Analysis Framework Using Symbolic Execution and Reversible x86 Instructions
• Soleimani and Balarostaghi, 2016, Seismic image enhancement in post stack depth migration by finite offset CDS stack method
• Kowalik and Nielek, 2016, Senior Programmers Characteristics of Elderly Users from Stack Overflow
• Chen and others, 2016, TechLand Assisting Technology Landscape Inquiries with Insights from Stack Overflow
• Chen and Xing, 2016, Towards Correlating Search on Google and Asking on Stack Overflow
• Adaji and Vassileva, 2016, Towards Understanding User Participation in Stack Overflow Using Profile Data
• Nankaku and others, 2015, A Dynamic Control Mechanism of Interrupt Stack Overflow on Real-Time Embedded Monitor REMON
• Yu and Cohen, 2015, Guided Test Generation for Finding Worst-Case Stack Usage in Embedded Systems
• Kwon and others, 2015, Mantis Efficient Predictions of Execution Time, Energy Usage, Memory Usage and Network Usage on Smart Mobile Devices
• Latorre and others, 2015, SODA the stack overflow dataset almanac
• Park and others, 2015, Software similarity analysis based on dynamic stack usage patterns
• Goel and Mehtre, 2015, Stack Overflow Based Defense for IPv6 Router Advertisement Flooding DoS Attack
• Ponzanelli and others, 2015, StORMeD Stack Overflow Ready Made Data
• Beyer and Pinzger, 2015, Synonym Suggestion for Tags on Stack Overflow

Proof-carrying code and certified artefacts

An artefact carrying machine-checkable evidence about itself is the subject of 7 contemporary records. This is the second smallest of the named clusters, after cost-preserving compilation, and it is the shape the article’s conclusion suggests the eventual answer takes.

• Du and others, 2026, A Strongly Typed Assembly Agent for Construction Integrating Rhino and Multimodal Large Language Models
• Krijnen and others, 2025, A Layered Certifying Compiler Architecture
• Song and others, 2025, Securing Cryptographic Software via Typed Assembly Language
• Kamran and others, 2024, Vision Paper Proof-Carrying Code Completions
• Namjoshi and Xue, 2021, A Self-certifying Compilation Framework for WebAssembly
• O’CONNOR and others, 2021, Cogent uniqueness types and certifying compilation
• Buisson and Rehab, 2018, Effective Bridging Between Ecore and Coq Case of a Type-Checker with Proof-Carrying Code

Types and semantics decide whether the question is even askable

Type systems and formal semantics account for 330 records. They belong here because a resource bound is a property of a program, and what a type system can express determines whether such a property can be stated in the source at all.

• Nawrocki and others, 2026, A Certifying Proof Assistant for Synthetic Mathematics in Lean
• Sakoda and others, 2026, A Formal Verification of Sequential GF 2 m Arithmetic Datapaths using Temporal-logic-based Formalization
• Guerdi, 2026, A Lambda-Superposition Tactic for Isabelle/HOL
• Amiot and others, 2026, aLEAKator HDL Mixed-Domain Simulation for Masked Hardware and Software Formal Verification
• Peltier, 2026, An EXPTIME-complete entailment problem in separation logic
• Wijs, 2026, An overview of research with Slco on seamless integration of formal verification into model-driven software engineering
• Fang, 2026, Compositional Formal Verification of Anti-Lock Braking System Neural Controllers
• Hao Su, 2026, Construction of a Memory Safety Model for Concurrent Programs Based on Formal Verification
• Vermande, 2026, Cylindrical Algebraic Decomposition in Coq/Rocq
• Thirion and others, 2026, Fault Model-Driven Formal Verification of Cryptographic Hardware Against Fault Attacks
• Casciani and others, 2026, Formal semantics for knowledge representation and automated reasoning in BPMN process models
• Barrière and others, 2026, Formal Verification for JavaScript Regular Expressions A Proven Mechanized Semantics and Its Applications
• Ltaief and others, 2026, Formal verification of fault tolerance mechanisms in multi-layer IoT using Event-B
• Khetkarn and others, 2026, Formal verification of time-bounded BPMN model with message broker using timed automata
• Sousa and others, 2026, Memory Safety in Linux Device Drivers Enhancing Security with Formal Verification
• Haselwarter and others, 2026, Modular Verification of Differential Privacy in Probabilistic Higher-Order Separation Logic
• Dominik, 2026, Polynomial Formal Verification
• Feng and Zhang, 2026, Survey of Consensus Protocol’s Formal Verification
• Cheng and Lu, 2026, SysML Model-Based Safety Analysis in Airborne System Design Using Formal Verification
• Nikita, 2026, The analogy theorem in Hoare logic for formal verification of knowledge transfer in machine learning
• Laurent and Vitek, 2026, Type Inference for Functional and Imperative Dynamic Languages
• Jacobs, 2026, VeriFast’s separation logic a logic without laters for modular verification of fine-grained concurrent programs
• Allain and Scherer, 2026, Zoo A Framework for the Verification of Concurrent OCaml 5 Programs using Separation Logic
• Zhao and others, 2025, A Formal Verification Method for Kernel Heap Allocation Modules Based on BIP
• Gummersbach and others, 2025, A Formally Verified Neural Network Converter for the Interactive Theorem Prover Coq
• Hallerstede and Hatcliff, 2025, A mechanized semantics for component-based systems in the HAMR AADL runtime
• Law and others, 2025, A Mechanized Semantics for Dataflow Circuits
• Dust and others, 2025, A model-based approach to automation of formal verification of ROS 2-based systems
• Chen and others, 2025, Automatic Model Transformation and Formal Verification for Function Block of IEC 61499
• Mosses, 2025, Checking a Denotational Semantics of Scheme in Agda
• Shaked and Melham, 2025, Contextualizing Formal Verification for Systems Security Engineering
• Stupnikov, 2025, Formal Semantics and Verification of Procedural SQL Programs Implementing Materialized Data Integration
• Mohanty and others, 2025, Formal That “Floats” High Formal Verification of Floating Point Arithmetic
• Hobbs, 2025, Formal Verification
• Mandinyenya and Malele, 2025, Formal Verification of a Blockchain-Based Security Model for Personal Data Sharing Using the Dolev-Yao Model and ProVerif
• Zheng and others, 2025, Formal Verification of a Crash-Safe File System Based on Non-Persistent Conditions Extended Concurrent Separation Logic
• Yang and others, 2025, Formal Verification of a Custom Compiler for a Fully Homomorphic Encryption Accelerator
• M. Ajaykumar and others, 2025, Formal Verification of Data Modifications in Cloud Block Storage Based on Separation Logic
• Asuai and Ponugoti, 2025, Formal Verification of LSQ-LFENCE for Memory Ordering and Security Assurance
• Zhao and others, 2025, Formal Verification of Preemptive Interrupt-Driven Programs Based on Partial Order Modeling
• Krishnan and others, 2025, Formal Verification of Safety Critical Software in Ada Two Approaches
• 2025, Formalizing Operational Semantics
• Kang and others, 2025, FVEval Understanding Language Model Capabilities in Formal Verification of Digital Hardware
• Chen and others, 2025, Hierarchical safety analysis and formal verification for safety-critical systems using STAMP and Event-B
• Jang and others, 2025, McTT A Verified Kernel for a Proof Assistant
• Tekriwal and Sottile, 2025, Mechanized Semantics for Correctness of the RS274 Additive Manufacturing Command Language
• Wray and Wang, 2025, PAVE++ Demo Cross-Layer Formal Verification and OTA Validation for UAV Communications
• Gao and others, 2025, Security model design and formal verification of MQTT protocol
• Hobbs, 2025, Semi-Formal Verification
• Lawall and others, 2025, Should We Balance? Towards Formal Verification of the Linux Kernel Scheduler
• Jha and others, 2025, Special Session Paper Formal Verification Techniques and Reliability Methods for RRAM-based Computing-in-Memory
• Vindum and others, 2025, The Nextgen Modality A Modality for Non-Frame-Preserving Updates in Separation Logic
• Zhao and others, 2025, Theoretical and Practical Approach to the Soundness and Completeness of Operational Semantics based on Denotational Semantics for MDESL
• Ziani and others, 2025, Towards Formal Verification of a TPM Software Stack Achievements and Opportunities
• Burski, 2025, Transforming Formal Verification - Insights from MALPAS
• Dinikeev, 2025, Type system for a statically typed concatenative programming language with first class function support
• Hamid, 2024, Nearest Neighbors You Can Rely On Formally Verified k-d Tree Construction and Search in Coq
• Wang and others, 2024, A Formal Verification Approach for Linux Kernel Designing
• Catta and others, 2024, A Formal Verification Approach to Handle Attack Graphs
• Li and others, 2024, A Formally Verified Scheme for Security Protocols with the Operational Semantics of Strand Space
• Hallerstede and Hatcliff, 2024, A Mechanized Semantics for Component-Based Systems in the HAMR AADL Runtime
• Li and others, 2024, A Nominal Approach to Probabilistic Separation Logic
• Peltier, 2024, An EXPTIME-Complete Entailment Problem in Separation Logic
• Xie and others, 2024, Automatic construction and verification algorithm for smart contracts based on formal verification
• 2024, Ensuring Safety and Reliability Formal Verification of Communication-Based Train Control Systems
• Lei and others, 2024, Exploring the Properties of Finit Coproduct in the Category of Riesz Modules A Semantic Approach to Denotational Semantics in Functional Programming Languages
• Zoughi and Deypir, 2024, Formal Verification of an Enhanced Deep Learning Model Unveiling Computational Effectiveness in Speech Recognition
• Zhang and others, 2024, Formal Verification of Data Modifications in Cloud Block Storage Based on Separation Logic
• Onderka, 2024, Formal Verification of Machine-Code Systems by Translation of Simulable Descriptions
• Nemouchi and others, 2024, Formally Verified ZTA Requirements for OT/ICS Environments with Isabelle/HOL
• Hinrichsen and others, 2024, Multris Functional Verification of Multiparty Message Passing in Separation Logic
• Nadeem and Drechsler, 2024, Polynomial Formal Verification of Multi-Valued Logic Circuits within Constant Cutwidth Architectures
• Zhou and others, 2024, Prover - Toward More Efficient Formal Verification of Masking in Probing Model
• Kim and others, 2024, SimplMM A simplified and abstract multicore hardware model for large scale system software formal verification
• Bergami, 2024, Streamlining Temporal Formal Verification over Columnar Databases
• Liu, 2024, Testing-Based Formal Verification
• Gunther and others, 2024, The formal verification of the ctm approach to forcing
• Yang and Wang, 2024, Toward Auto-Modeling of Formal Verification for NextG Protocols A Multimodal Cross- and Self-Attention Large Language Model Approach
• Shirinzadeh and others, 2024, Towards Formal Verification for MAC-based In-Memory Computing
• YE and OLIVEIRA, 2024, Type-directed operational semantics for gradual typing
• Eilers and others, 2024, Verification Algorithms for Automated Separation Logic Verifiers
• Matheja and others, 2023, A Decision Procedure for Guarded Separation Logic Complete Entailment Checking for Separation Logic with Inductive Definitions
• Boudi and others, 2023, A Deep Reinforcement Learning Framework with Formal Verification
• Patil and others, 2023, A Technique of X-PROP Verification of Power-Aware Debug Logic Integration Using Formal Verification Techniques
• Seligman and others, 2023, Basic formal verification algorithms
• Zieliński, 2023, Explanatory Denotational Semantics for Complex Event Patterns
• Devadze and others, 2023, Formal Verification of a Controller Implementation in Fixed-Point Arithmetic
• Yan and Yu, 2023, Formal Verification of a Topological Spatial Relations Model for Geographic Information Systems in Coq
• Rashid and others, 2023, Formal Verification of Aircraft Departure Procedure Using Spin Model Checker
• Noce, 2023, Formal Verification of Cryptographic Protocols with Isabelle/HOL
• Tloul and others, 2023, Formal Verification of Dynamical Control Systems Addressing Integral Windup Phenomena Using Model-Checking
• Pal and Johnson, 2023, Formal Verification of Long Short-Term Memory based Audio Classifiers A Star based Approach
• Kochan and others, 2023, Formal Verification of the European Train Control System ETCS for Better Energy Efficiency Using a Timed and Asynchronous Model
• Seligman and others, 2023, Formal verification from dreams to reality
• Siapoush and Alves-Foss, 2023, Is Formal Verification of seL4 Adequate to Address the Key Security Challenges of Kernel Design?
• Jung and others, 2023, Modular Verification of Safe Memory Reclamation in Concurrent Separation Logic
• Schnieber and Drechsler, 2023, Polynomial Formal Verification of KFDD Circuits
• Affeldt and others, 2023, Semantics of Probabilistic Programs using s-Finite Kernels in Coq
• Schellhorn and others, 2023, Separating Separation Logic Modular Verification of Red-Black Trees
• Ziani and others, 2023, Towards Formal Verification of a TPM Software Stack
• Sharma and others, 2023, Using Deep Reinforcement Learning And Formal Verification in Safety Critical Systems Strategies and Challenges
• Somogyi and Mezei, 2023, Verifying Static Constraints on Models Using General Formal Verification Methods
• Milano and others, 2022, A flexible type system for fearless concurrency
• Steiner and others, 2022, A Framework for Formal Verification of DRAM Controllers
• Oeyen and others, 2022, A Graph-Based Formal Semantics of Reactive Programming from First Principles
• Mündler and Nipkow, 2022, A Verified Implementation of B ^+ -Trees in Isabelle/HOL
• DANNER and LICATA, 2022, Denotational semantics as a foundation for cost recurrence extraction for functional languages
• Abdulaziz and Koller, 2022, Formal Semantics and Formally Verified Validation for Temporal Planning
• 2022, Formal Verification of Autonomous System Software
• Tran and Ogata, 2022, Formal verification of TLS 1.2 by automatically generating proof scores
• Haur and others, 2022, Formal Verification of the Inter-core Synchronization of a Multi-core RTOS Kernel
• 2022, ML and type inference
• Yan and others, 2022, Model-based Generation of Hazard-driven Arguments and Formal Verification Evidence for Assurance Cases
• Nieto and others, 2022, Modular verification of op-based CRDTs in separation logic
• Perez and others, 2022, Optimization Techniques and Formal Verification for the Software Design of Boolean Algebra Based Safety-Critical Systems
• Xiang and others, 2022, Parameterized Design and Formal Verification of Multi-ported Memory
• Niemann and Drechsler, 2022, Polynomial-Time Formal Verification of Adder Circuits for Multiple-Valued Logic
• XING and others, 2022, PROMELA based formal verification for safety-critical software
• Huang and others, 2022, Prompt-tuned Code Language Model as a Neural Knowledge Base for Type Inference in Statically-Typed Partial Code
• Pollak and others, 2022, Scala Type System
• Haase and others, 2022, Separation logic and logics with team semantics
• Hermans, 2022, Type Assignment and Type Inference
• Batko and Kuta, 2022, Type System of Anemone Functional Language
• Tsimbolynets and Perháč, 2022, Visualization of imperative programs translation with Structural Operational Semantics
• Mihelic and others, 2021, A denotational semantics of a concatenative/compositional programming language
• Zhou and others, 2021, A Quantum Interpretation of Bunched Logic and Quantum Separation Logic
• Jipsen and Litak, 2021, An Algebraic Glimpse at Bunched Implications and Separation Logic
• Yu and others, 2021, An I/O Separation Model for Formal Verification of Kernel Implementations
• Khan and others, 2021, CoCEC An Automatic Combinational Circuit Equivalence Checker Based on the Interactive Theorem Prover
• Steingartner, 2021, Compiler Module of Abstract Machine Code for Formal Semantics Course
• Le, 2021, Compositional Satisfiability Solving in Separation Logic
• Ekembe Ngondi, 2021, Denotational semantics of channel mobility in UTP-CSP
• Gondelman and others, 2021, Distributed causal memory modular specification and verification in higher-order distributed separation logic
• Punnoose, 2021, Ensuring completeness of formal verification with Gap Free Verification
• Shah and Agrawal, 2021, Formal Verification Aware Redundant Sequential Logic Optimization to Improve Design Utilization
• Guan and others, 2021, Formal Verification of a Hybrid IoT Operating System Model
• Tao and others, 2021, Formal Verification of a Multiprocessor Hypervisor on Arm Relaxed Memory Hardware
• Boumaza and others, 2021, Formal Verification of Emergent Properties
• Kortik and Shastha, 2021, Formal Verification of ROS Based Systems Using a Linear Logic Theorem Prover
• Humphrey and others, 2021, Formal verification of safety-critical software using SPARK
• Djeddi and others, 2021, Formal verification of the extension of iStar to support Big data projects
• Dave, 2021, FVCARE Formal Verification of Security Primitives in Resilient Embedded SoCs
• Galmiche and Méry, 2021, Labelled cyclic proofs for separation logic
• Cluzel and others, 2021, Layered Formal Verification of a TCP Stack
• Xavier and others, 2021, Plant Model Generator from Digital Twin for Purpose of Formal Verification
• Twigg and others, 2021, Predicting Formal Verification Resource Needs Computation Time and Memory through Machine Learning
• Krishna and others, 2021, Separation Logic
• Sugai and others, 2021, SMT-Based Theorem Verification for Testing-Based Formal Verification
• Demri and others, 2021, The Effects of Adding Reachability Predicates in Quantifier-Free Separation Logic
• Lu and others, 2021, Towards Formal Verification of Dynamic Memory Allocator Properties Using BIP Framework
• Qian and others, 2021, Verification of Operating Systems for Internet of Things in Smart Cities From the Assembly Perspective Using Isabelle/HOL
• Ciobanu and others, 2020, Accidental Sensitive Data Leaks Prevention via Formal Verification
• Jabbar and others, 2020, Adopting Formal Verification and Model-Based Testing Techniques for Validating a Blockchain-based Healthcare Records Sharing System
• Rechmal-Lesse and others, 2020, Automated Model Generation Including Variations for Formal Verification of Nonlinear Analog Circuits
• Zúñiga and Bel-Enguix, 2020, Coinductive Natural Semantics for Compiler Verification in Coq
• Ye and others, 2020, Components Interaction Safety Analysis Method Based on STAMP and Formal Verification
• Melliès and Stefanesco, 2020, Concurrent Separation Logic Meets Template Games
• Park and others, 2020, End-to-End Formal Verification of Ethereum 2.0 Deposit Smart Contract
• Punnoose, 2020, Ensuring completeness of formal verification with Gap Free Verification
• Cimini and others, 2020, Extrinsically typed operational semantics for functional languages
• 2020, Formal verification for SoC security
• Hariati, 2020, Formal Verification Issues For Component-Based Development
• Rivera, 2020, Formal Verification of Access Control Model for My Health Record System
• Kosmatov and others, 2020, Formal Verification of an Industrial Distributed Algorithm An Experience Report
• Grobelna, 2020, Formal Verification of Control Modules in Cyber-Physical Systems
• Lu and others, 2020, Formal verification of discrete event model
• Ma and others, 2020, Formal Verification of Memory Isolation for the TrustZone-based TEE
• Qin and others, 2020, Formal verification of ontology transformation for distribution network information model based on meta-model theory
• Chabbat and others, 2020, Formal Verification of UML MARTE Specifications Based on a True Concurrency Real Time Model
• Raad and others, 2020, Local Reasoning About the Presence of Bugs Incorrectness Separation Logic
• Yang and Lei, 2020, Lolisa Formal Syntax and Semantics for a Subset of the Solidity Programming Language in Mathematical Tool Coq
• Ahn, 2020, Mechanized Proof of Type Preservation for Polymorphic Lambda Calculi Using Abella
• Andrade Guzmán and Hernández Quiroz, 2020, Natural deduction and semantic models of justification logic in the proof assistant Coq
• Fawzy and others, 2020, Noise Reduction in Reset Domain Crossings Verification Using Formal Verification
• Choucha and others, 2020, On Decomposing Formal Verification of CTL-based Properties on IaaS Cloud Environment
• Cousot, 2020, On Fixpoint/Iteration/Variant Induction Principles for Proving Total Correctness of Programs with Denotational Semantics
• Jones, 2020, Operational semantics
• Brotherston and others, 2020, Reasoning over Permissions Regions in Concurrent Separation Logic
• Makri and Psillakis, 2020, Reliability and importance measures for a general consecutive-type system
• Mehta and Cook, 2020, Separation Logic-Based Verification Atop a Binary-Compatible Filesystem Model
• Chhaya and Jafer, 2020, Simulation-Based and Formal Verification of Domain-Specific Language Model
• Echenim and others, 2020, The Bernays-Schönfinkel-Ramsey Class of Separation Logic with Uninterpreted Predicates
• Dasgupta and others, 2019, A complete formal semantics of x86-64 user-level instruction set architecture
• Benzaken and Contejean, 2019, A Coq mechanised formal semantics for realistic SQL queries formally reconciling SQL and bag relational algebra
• Najem, 2019, A formal semantics for supporting the automated synthesis of choreography-based architectures
• Liu and others, 2019, Automatic Grading of Programming Assignments An Approach Based on Formal Semantics
• Tatsuta and others, 2019, Completeness and expressiveness of pointer program verification by separation logic
• Zwanziger, 2019, Dependently-Typed Montague Semantics in the Proof Assistant Agda-flat
• Cai and others, 2019, Design Model Repair with Formal Verification
• de Oliveira and others, 2019, Efficient Formal Verification for the Linux Kernel
• Widell and Harder, 2019, Formal semantics and functional semantics
• Nakamura and Sakakibara, 2019, Formal Verification and Mathematical Optimization for Autonomous Vehicle Group Controllers
• Barthe and others, 2019, Formal verification of a constant-time preserving C compiler
• Kordic and others, 2019, Formal Verification of Python Software Transactional Memory Based on Timed Automata
• Popovic and others, 2019, Formal Verification of Python Software Transactional Memory Serializability Based on the Push/Pull Semantic Model
• Kutsak and Podymov, 2019, Formal Verification of Three-Valued Digital Waveforms
• Peterson and Dechev, 2019, Formal Verification through Combinatorial Topology
• Thiemann, 2019, Intrinsically-Typed Mechanized Semantics for Session Types
• Sharan, 2019, Local Variable Type Inference
• Ahn, 2019, Mechanized Proof for Type Preservation of GTLC
• Ter-Gabrielyan and others, 2019, Modular verification of heap reachability properties in separation logic
• Smith and Thornton, 2019, Quantum Logic Synthesis with Formal Verification
• Nallamalli and Chauhan, 2019, Rapid Formal Verification as Requirements Stage Verification and Validation Technique
• Dickson Lawrence J. and Martin Jeremy M.R., 2019, Rigorous Timing, Static occam, and Classic CSP Formal Verification for IoT
• Ernst and Murray, 2019, SecCSL Security Concurrent Separation Logic
• O’Hearn, 2019, Separation logic
• Hamlen and others, 2019, Source-free Machine-checked Validation of Native Code in Coq
• Turcotte and Vitek, 2019, Towards a Type System for R
• Ahamad and Pathan, 2019, Trusted service manager TSM based privacy preserving and secure mobile commerce framework with formal verification
• Eberl, 2019, Verified Real Asymptotics in Isabelle/HOL
• Wolfengagen and others, 2018, A Cognitive Type System Simulation by a Dynamically Typed Language
• Brucker and Herzberg, 2018, A Formal Semantics of the Core DOM in Isabelle/HOL
• de Putter and Wijs, 2018, A formal verification technique for behavioural model-to-model transformations
• Fradet and others, 2018, A Generic Coq Proof of Typical Worst-Case Analysis
• Moin and others, 2018, A Model-driven Approach for Formal Verification of Embedded Systems Using Timed Colored Petri Nets
• Racordon and Buchs, 2018, A practical type system for safe aliasing
• Daudier and others, 2018, A Proof Score Approach to Formal Verification of an Imperative Programming Language Compiler
• Grimm and others, 2018, A Survey on Formal Verification Techniques for Safety-Critical Systems-on-Chip
• Bosse, 2018, A Unified System Modelling and Programming Language based on JavaScript and a Semantic Type System
• Joosten and others, 2018, A Verified Implementation of Algebraic Numbers in Isabelle/HOL
• Melliès and Stefanesco, 2018, An Asynchronous Soundness Theorem for Concurrent Separation Logic
• D. Jurcut, 2018, Automated Logic-Based Technique for Formal Verification of Security Protocols
• Hua and Hein, 2018, Concept Learning in AutomationML with Formal Semantics and Inductive Logic Programming
• 2018, Formal verification
• Zhang and Wu, 2018, Formal verification and quantitative metrics of MPSoC data dynamics
• Todorov and others, 2018, Formal verification of automotive embedded software
• Leroy, 2018, Formal Verification of Code Generators for Modeling Languages
• Narodytska, 2018, Formal Verification of Deep Neural Networks
• Feng, 2018, Formal Verification of Double Two out of Two Computer Systems
• 2018, Formal Verification of Financial Algorithms with Imandra
• Boussif and Ghazel, 2018, Formal verification of intermittent fault diagnosability of discrete-event systems using model-checking
• 2018, Formal Verification of Unsatisfiability Results
• Galvão and others, 2018, Formal Verification Focused on the Verification Using a Plant Model
• Lenglet and Schmitt, 2018, HOπ in Coq
• Iosif, 2018, Program Verification with Separation Logic
• Sokhatskyi and Maslianko, 2018, The systems engineering of consistent pure language with effect type system for certified applications and higher languages
• Lenko and others, 2018, Type- Theoretical Foundations of the Derivation System in Coq
• Bao and others, 2018, Unifying separation logic and region logic to allow interoperability
• Zhan and Haslbeck, 2018, Verifying Asymptotic Time Complexity of Imperative Programs in Isabelle
• Le and others, 2017, A Decidable Fragment in Separation Logic with Inductive Predicates and Arithmetic
• Gabmeyer and others, 2017, A feature-based classification of formal verification techniques for software models
• KULKARNI and RAO, 2017, A Formal Verification Model for Performance Analysis of Reinforcement Learning Algorithms Applied to Dynamic Networks
• Marconi and others, 2017, A model-driven approach for the formal verification of storm-based streaming applications
• Erata and others, 2017, A tool for automated reasoning about traces based on configurable formal semantics
• Kordic and others, 2017, An approach to formal verification of python software transactional memory
• Mainland, 2017, Better living through operational semantics an optimizing compiler for radio protocols
• Basile and others, 2017, Enhancing Models Correctness through Formal Verification A Case Study from the Railway Domain
• Niang and others, 2017, Formal Verification for Validation of PSEEL’s PLC Program
• Brunner and Lammich, 2017, Formal Verification of an Executable LTL Model Checker with Partial Order Reduction
• Bahig and El-Kadi, 2017, Formal Verification of Automotive Design in Compliance With ISO 26262 Design Verification Guidelines
• Abate, 2017, Formal verification of complex systems
• Kottler and others, 2017, Formal verification of ladder logic programs using NuSMV
• Brinkmann and Kelf, 2017, Formal Verification-The Industrial Perspective
• Ge and others, 2017, Integrated formal verification of safety-critical software
• Hölzl, 2017, Markov processes in Isabelle/HOL
• Genius and others, 2017, Model-Driven Performance Evaluation and Formal Verification for Multi-level Embedded System Design
• Fu and Komendantskaya, 2017, Operational semantics of resolution and productivity in Horn clause logic
• Vafeiadis, 2017, Program Verification Under Weak Memory Consistency Using Separation Logic
• Reynolds and others, 2017, Reasoning in the Bernays-Schönfinkel-Ramsey Fragment of Separation Logic
• Lee, 2017, Standard ML Type Inference
• Aravantinos and Kanav, 2017, Tool Support for Live Formal Verification
• Guo and others, 2017, Work-in-Progress Toward a Coq-Certified Tool for the Schedulability Analysis of Tasks with Offsets
• Reynolds and others, 2016, A Decision Procedure for Separation Logic in SMT
• Swierstra and others, 2016, A Lazy Language Needs a Lazy Type System
• Ramananandro and others, 2016, A unified Coq framework for verifying C programs with floating-point computations
• Guo and others, 2016, Automatic RTL-to-Formal Code Converter for IP Security Formal Verification
• Kebaili and others, 2016, Clock domain crossing formal verification a meta-model
• Murray and others, 2016, Crowd-Sourced Help with Emergent Knowledge for Optimized Formal Verification CHEKOFV
• Demri and Deters, 2016, Expressive Completeness of Separation Logic with Two Variables and No Separating Conjunction
• Song, 2016, Formal verification for computer security Lessons learned and future directions
• M and S., 2016, Formal Verification of a Secure Model for Building E-Learning Systems
• Brunner and Lammich, 2016, Formal Verification of an Executable LTL Model Checker with Partial Order Reduction
• Kashi and others, 2016, Formal verification of avionics self adaptive software
• Blazy and Trieu, 2016, Formal verification of control-flow graph flattening
• 2016, Formal Verification of DEVS Simulation Web Search Engine Model Case Study
• Cifuentes and others, 2016, Formal verification of distributed system using an executable C model
• Feliachi and others, 2016, Formal verification of system-level safety properties on railway software
• Thiemann and Yamada, 2016, Formalizing Jordan normal forms in Isabelle/HOL
• Charguéraud, 2016, Higher-order representation predicates in separation logic
• Kothari and others, 2016, Insights for Practicing Engineers from a Formal Verification Study of the Linux Kernel
• Gheorghe and others, 2016, Kernel P Systems and Stochastic P Systems for Modelling and Formal Verification of Genetic Logic Gates
• Pandey, 2016, Machine learning and systems for the next frontier in formal verification
• Petnga and Austin, 2016, Model-Based Design and Formal Verification Processes for Automated Waterway System Operations
• 2016, Panel - Killer apps not your father’s formal verification
• Friedman, 2016, Perspectives on formal verification invited talk
• Noonan and others, 2016, Polymorphic type inference for machine code
• Cerqueira and others, 2016, PROSA A Case for Readable Mechanized Schedulability Analysis
• Feo-Arenis and others, 2016, Ready for testing ensuring conformance to industrial standards through formal verification
• Singh and Natarajan, 2016, Separation Logic to Meliorate Software Testing and Validation
• Bruza, 2016, Syntax and operational semantics of a probabilistic programming language with scopes
• Liu, 2016, Testing-Based Formal Verification for Algorithmic Function Theorems and Its Application to Software Verification and Validation
• Ward and Zedan, 2016, The formal semantics of program slicing for nonterminating computations
• Kaliszyk and others, 2016, Towards a Mizar environment for Isabelle foundations and language
• Aguado and others, 2016, Verification for ASP denotational semantics a case study using the PVS theorem prover
• Ernst, 2016, Verification Games Crowd-Sourced Formal Verification
• Eberl, 2015, A Decision Procedure for Univariate Real Polynomials in Isabelle/HOL
• Dasgupta, 2015, A Logical Perspective of Formal Verification A Narrative on the Genesis and Evolution of the Formal Verification Group at IIT Kharagpur
• Courtault and Galmiche, 2015, A modal separation logic for resource dynamics
• Dongol and others, 2015, A Program Construction and Verification Tool for Separation Logic
• Brain and others, 2015, An Automatable Formal Semantics for IEEE-754 Floating-Point Arithmetic
• Rodríguez, 2015, An Intrinsic Denotational Semantics for a Lazy Functional Language
• Seligman and others, 2015, Basic formal verification algorithms
• Kunčar, 2015, Correctness of Isabelle’s Cyclicity Checker
• Hanna, 2015, Democratization of formal verification with collective intelligence
• Abramsky and Horsman, 2015, DEMONIC programming a computational language for single-particle equilibrium thermodynamics, and its formal semantics
• Bertot, 2015, Fixed Precision Patterns for the Formal Verification of Mathematical Constant Approximations
• Cristia and Frydman, 2015, Formal and semi-formal verification of a web voting system
• Seligman and others, 2015, Formal verification
• Ghannoudi and Chainbi, 2015, Formal verification for Web service composition A model-checking approach
• Hocking and others, 2015, Formal Verification in Model Based Development
• Narisawa and others, 2015, Formal Verification Method for Safety Diagnosis Software
• Kalla, 2015, Formal verification of arithmetic datapaths using algebraic geometry and symbolic computation
• Burlyaev and Fradet, 2015, Formal verification of automatic circuit transformations for fault-tolerance
• Kropacheva and Legalov, 2015, Formal Verification of Programs in Functional Dataflow Parallel Language
• Thole and Fey, 2015, Formal Verification of Robustness
• Seligman and others, 2015, Formal verification’s greatest bloopers
• Blanchette and others, 2015, Foundational extensible corecursion a proof assistant perspective
• Tanter and Tabareau, 2015, Gradual certified programming in coq
• Guoqi and others, 2015, Hybrid formal verification of greenhouse temperature-humidity system based on MLD model
• Schmidt-Schauß and Sabel, 2015, Improvements in a functional core language with call-by-need operational semantics
• 2015, Metamodelling with Formal Semantics with Application to Access Control Specification
• Enea and others, 2015, On Automated Lemma Generation for Separation Logic with Inductive Definitions
• Cao and others, 2015, Practical Tactics for Verifying C Programs in Coq
• Vafeiadis, 2015, Separation logic for weak memory models
• Borhalenko, 2015, THE AUTOMATA INTRUDER MODEL FOR DATA EXCHANGE CRYPTOGRAPHIC PROTOCOLS FORMAL VERIFICATION
• Ricketts and others, 2015, Towards verification of hybrid systems in a foundational proof assistant
• Demri and Deters, 2015, Two-Variable Separation Logic and Its Inner Circle
• Bidmeshki and Makris, 2015, VeriCoq A Verilog-to-Coq converter for proof-carrying hardware automation
• Kiss and others, 2015, Verification of protocol specifications with Separation Logic
• Demange and others, 2015, Verifying Fast and Sparse SSA-Based Optimizations in Coq

Real-time and certification, which is who consumes the evidence

814 contemporary records make this the largest of the named clusters, and its size is a fact about who pays for this work. Resource bounds are not an academic curiosity. They are a certification requirement in avionics and automotive software, and the literature is correspondingly industrial.

• Vaccargiu and others, 2026, A Blockchain-Oriented Software Engineering Architecture for Carbon Credit Certification Systems
• Zhao and others, 2026, A Combined STPA and ISO 26262 Approach for Safety Analysis of an EcoCAR Propulsion System
• Umer, 2026, A practical implementation of customized Scrum-based Agile framework in aerospace software development under DO-178C constraints
• Behera and Singh, 2026, A safety-aware deep learning framework for scalable schedulability analysis of variable-length real-time task sets
• Soleimani and Sari, 2026, A unified safety framework for automated vehicle development integrating ISO 26262, SOTIF, and UL 4600
• Bai Kotin, 2026, Agile Transformation In Safety-Critical Avionics Certification A Hybrid Execution Model For DO-178B/C Compliance And Cycle Time Optimization
• Abdul Karim, 2026, AI-Enhanced Functional Safety in ADAS Controllers Predictive Fault Management under ISO 26262
• Mendias and others, 2026, Application of ISO 26262 to Automotive Semiconductors
• Mari and Wen, 2026, Assessing Python’s suitability for airborne safety-critical systems under DO-178C guidelines
• Bhagwat and others, 2026, Automating DO-178C Verification and Security Compliance in DevSecOps CI/CD Pipelines for Safety Critical Avionics Software
• Arumugam, 2026, Bridging Certification and Agile Development in Safety Critical Airborne Software An Incremental DO-178C Assurance Framework
• Deepak and others, 2026, Design and Application of ISO 26262 Compliant Engine Control Unit for Safety and Performance at Software Level 1 and Level 2
• Panchal and others, 2026, DO-178C software development lifecycle with ARP4754A system-level verification
• Anselmi and others, 2026, Energy Minimization in Real-Time Systems from Worst-Case Guarantees to Statistical Learning
• Andriaccio and Abeni, 2026, EVA-rt-Engine Evaluation, Verification and Analysis Engine for Real-Time Applications Schedulability
• Rabbiun and others, 2026, Exact and sufficient schedulability tests for adaptive weakly-hard real-time mixed-criticality systems
• Bondar and others, 2026, Generative Profiling for Soft Real-Time Systems and its Applications to Resource Allocation
• Jain, 2026, Harmonizing Generative AI and ISO 26262 for Safe and Intelligent ADAS Systems
• Kim and Kim, 2026, Identifying Factors Influencing Public Service Satisfaction Focusing on Software Certification Consulting Support Services
• Barua, 2026, Integrated Safety Architectures Leveraging Multi-Modal AI and ISO 26262 to Protect Vulnerable Road Users
• Zrelli and others, 2026, Integrating formal methods and automated tools for DO-178C compliance in UAV software
• Hu, 2026, Keynote III ISSSR 2026 AI-Enhanced Safety Critical Software Development
• Sakurai, 2026, LLM-Optimized Fault Tree Analysis for the Probabilistic Metric for Random Hardware Failures under ISO 26262
• Zafar, 2026, Orthogonal Axiomatic CI/CD for Safety-Critical AI Systems Considering ISO-26262, DO-178C, EU AI Act for Audit readiness, Deployment Velocity, Incident Resolution, Liability Reduction
• Şapci and others, 2026, Parameter Data Item PDI Approach for Software Considerations in DO-178C
• Hölscher and others, 2026, Releaser Design and Schedulability Analysis for Care-Taking Tasks in Real-Time Systems
• Song and others, 2026, Research on the Schedulability of Sporadic Tasks in Spaceborne Mixed Real-Time Operating System
• Rahul and Benikireddy, 2026, Risk-Driven Program Management Framework for Avionics Development Integration of Safety, Certification, and Cybersecurity Standards
• Shevchenko and others, 2026, The dimension of the PMHF functional safety metric of ISO 26262 standard
• Casanova and others, 2026, Towards a Software Architecture to Integrate Case Based-Reasoning and Large Language Models for Fishery Product Certification
• Speth and others, 2026, Traceable Metamorphic Test Cases for Robust Safety-Critical Systems A Deep Learning LiDAR Object Detector Example
• Xie and others, 2026, Uncertainty-Driven Risk Evaluation for Safety-Critical Software Under Conflicting Evidence Judgments A Dual-Dimensional Evidence Fusion Approach
• Praselski and Sunter, 2026, Using Analog IJTAG to Measure ISO 26262 Metrics
• 2026, Validation Framework for Safety-Critical Software in Software-Defined Vehicles Using Hardware-in-the-Loop and Co-Simulation Techniques
• Machado and others, 2026, Verified Tensor Operators for Safety-Critical ML From Specification to Reference Implementation
• Ahmed and others, 2026, Weakly-Hard Real-Time Flow Scheduling in Time-Sensitive Networks
• Sayakov, 2026, Why Large Language Models Cannot Be Certified for Safety-Critical Systems
• Del Hierro Cadena, 2025, A Hybrid Requirements Engineering Methodology for Certification of Medical Device Software
• Kim and others, 2025, A Study on the Use of ISO 26262 to Enhance Functional Safety
• Shi and others, 2025, Accelerating Timing Specification Verification of Interrupt-Driven Real-Time Systems
• Petrucci and others, 2025, AI/ML for Safety-Critical Software The Case of the Space Domain
• Xavier Dormoy and Dion, 2025, Alternative DO-178C Verification Workflow for Enhanced Productivity
• Garanina, 2025, An Exact Schedulability Test for Real-Time Systems with an Abstract Scheduler on Multiprocessor Platforms
• Benkendorf and others, 2025, An ISO 26262-Derived Evaluation Methodology for Automated Fault Injection Test Case Generators
• Zhang and others, 2025, An Open-Source Structural Coverage Tool for DO-178C Compliance
• Salecker and Faymonville, 2025, Analysis Methods for Safety-critical Software
• Iyenghar, 2025, Bridging Gaps in ISO 26262 for Testing Machine Learning ML Systems
• Daiene de Oliveira Bastos and others, 2025, Bridging the Gaps A Comparative Analysis of ISO 21434, ISO 26262 and Machine Learning in Autonomous Vehicles
• Jackson, 2025, Certification, Safety, and Software
• Almeida and others, 2025, Compiler Assisted Application Hardening An ISO 26262-Oriented Evaluation Using Virtualized Fault Injection
• Jadhav and Falk, 2025, Compiler-level DMA-aware multi-objective dynamic SPM allocation
• Xu and Li, 2025, Design of ABS Functional Safety Architecture Based on ISO 26262
• Li and Xu, 2025, Design of functional safety software based on the onboard tc3xx chip
• Rim and others, 2025, Deterministic and Probabilistic Schedulability Analysis for Real-Time Systems
• Kwon and others, 2025, DO-178C/DO-331 Certification Data Development Case Study Autopilot Software onboard Light Sports Aircraft
• Patil and others, 2025, DPAPC Deterministic Process-Aware Partitioned Cache for Real-Time Systems
• Moyano and others, 2025, Efficient Scheduling of Weakly-Hard Real-Time Tasks with Sufficient Schedulability Condition
• Karamti, 2025, Energy Efficiency and Schedulability Examination for Real-Time Multiprocessor Systems via Employing Machine Learning Techniques
• Sujan Rao, 2025, FUNCTIONAL SAFETY IN AUTOMOTIVE SEMICONDUCTORS A COMPREHENSIVE REVIEW OF ISO 26262 PRACTICES
• Kirchner and Knoll, 2025, Generating Automotive Code Large Language Models for Software Development and Verification in Safety-Critical Systems
• Descharmes and others, 2025, Global Versus Local Schedulability Analysis of a Two-Level Hierarchical System
• Nasri and Baruah, 2025, Guest editorial a roadmap towards learning-enabled and learning-assisted real-time systems
• Xue and Wang, 2025, Human-in-the-Loop Intelligent Testing for Safety-Critical Software
• Sun and others, 2025, ISO 26262-Aligned Functional Safety Verification Framework with Explainable Graph Neural Network
• Baruah and others, 2025, Learning-assisted schedulability analysis opportunities and limitations
• Chen and others, 2025, LEFT-RS A Lock-Free Fault-Tolerant Resource Sharing Protocol for Multicore Real-Time Systems
• LaRue and Ruiz, 2025, Leveraging ISO 26262-2018 to Support MIL-STD-882E Compliance
• Ciopiński, 2025, Methodology of an Energy Efficient-Embedded Self-Adaptive Software Design for Multi-Cores and Frequency-Scaling Processors Used in Real-Time Systems
• Atsushi, 2025, Point Unavailability and its Density Processes with Periodic Inspections in ISO 26262
• Capel, 2025, Real-Time Systems
• Wu and others, 2025, Reliability analysis of a vehicle motor control unit in consideration of functional safety of ISO 26262
• Xi and others, 2025, Research on Software Architecture Design Based on Functional Safety
• Luo, 2025, Research on the Analysis of Software Development Processes Based on GJB5000B and DO-178C
• Fan and others, 2025, Research on the MC/DC Test on Civil Aircraft Software Robust Requirements Based on DO-178C
• Rastari and others, 2025, Resource-Aware Neural Architecture Search for Multicore Embedded Real-Time Systems
• Zhang and others, 2025, Resource-Aware Task Scheduling and Allocation Framework for Multicore Real-Time Systems
• Meng and others, 2025, RITE An IDE for Assurance and Certification of Software and Systems
• Mäki-Turja and others, 2025, Rubus Offline Scheduler for Resource Constrained Embedded Real-Time Systems
• Latif and others, 2025, Safety-Oriented Evaluation of Embedded C Coding Methodologies for Automotive Software Using MISRA C and ISO 26262 Standards
• Yuvaraj J Patil, 2025, Scenario-Driven Safety Verification A Comprehensive Framework for Autonomous Vehicle Validation within ISO 26262
• Bertolotti and Manduchi, 2025, Schedulability Analysis Based on Response Time Analysis
• Bertolotti and Manduchi, 2025, Schedulability Analysis Based on Utilization
• Eduardo Ferreira Ribeiro and others, 2025, Scrum4DO178C An Agile Process to Enhance Aerospace Software Development for DO-178C Compliance-A Case Study at Criticality Level A
• Bertolotti and Manduchi, 2025, Self-Suspension and Schedulability Analysis
• Shi and Chen, 2025, Shielded reinforcement learning for fault-tolerant scheduling in real-time systems
• Thomas, 2025, Shorten Time to Market for ISO 26262 ASIL D Certification The Lion of Functional Safety’s Novel Approach
• Marcella, 2025, Software Certification of AI Systems
• Kozhevnikova, 2025, SOFTWARE FOR THE CERTIFICATION OF IODINE-IMPREGNATED SORBENTS OF AIR FILTERS OF NPP
• Shyshatska and others, 2025, Specification and Verification of a Formal Model for a Real-Time System Using TLA+
• Steiner and others, 2025, Split’n’Cover ISO 26262 Hardware Safety Analysis with SystemC
• Li, 2025, SREQ A Structured Approach to Safety Requirements Modeling for ADS under ISO 26262
• Moyano and others, 2025, Sufficient Schedulability Condition for Scheduling Weakly-Hard Real-Time Tasks Considering Job-Kill and Skip-Next Strategies
• Holzmann, 2025, The Analysis of Safety Critical Software Systems
• Almeida, 2025, The Real-Time Systems journal and the challenges ahead
• Casini, 2025, To MILP or not to MILP? On AI techniques for the design and optimization of real-time systems
• Buttazzo, 2025, Toward predictable AI-based real-time systems
• Willemsen and others, 2025, Transfer Schedulability in Periodic Real-Time Systems
• Strnadel, 2025, Using Statistical Model Checker for Schedulability Analysis of Real-Time Systems Under Uncertainty
• Häberlein and others, 2025, Watwaos A Framework for Worst-Case-Aware Tailoring and Whole-System Analysis of Energy-Constrained Real-Time Systems
• Bakita and Anderson, 2025, Work in Progress Increasing Schedulability via on-GPU Scheduling
• Fischer and Falk, 2025, Work in Progress Optimizing Schedulability Using Cache-Bypassing
• Klashtorny and others, 2024, A Compiler Phase to Optimally Split GPU Wavefronts for Safety-Critical Systems
• Ragchaa and others, 2024, A Design of Fault-Tolerant Battery Monitoring IC for Electric Vehicles Complying With ISO 26262
• Hoornaert and others, 2024, A Dynamic Priority-aware Coherent Cache Architecture for Reactive Real-Time System
• Quan and Li, 2024, A Event-B-Based Approach for Schedulability Analysis For Real-Time Scheduling Algorithms through Deadlock Detection
• Ramegowda, 2024, A Non-Intrusive Approach for Measuring Data and Control Coupling b/w Software Components Addressing the Challenges of DO-178C Compliance, Verification and Certification
• Panchal and others, 2024, A Pragmatic Approach to DO-178C-Inclined Software Development for Lift-to-Cruise Aircraft Nonlinear Flight Control
• Matilde and Marques, 2024, A RTCA DO-178C oriented method to develop Electronic Flight Bag Software
• Lim and Sung, 2024, A Study on V2X Communication System Test Strategy using ASPICE and ISO 26262
• Iyenghar and others, 2024, A Systematic Approach to Enhancing ISO 26262 With Machine Learning-Specific Life Cycle Phases and Testing Methods
• Rabbiun and others, 2024, Advanced Schedulability Testing for Adaptive Mixed-Criticality Systems under Weakly Hard Real-Time Constraints
• Kothinti, 2024, Advancing Functional Safety in Automated Driving A Methodological Approach to Legacy System Integration under ISO 26262
• Joshi and Jose, 2024, Airworthy-Certification Compliant Specification Modeling Framework for Avionics Development
• Liu and others, 2024, An efficient schedulability analysis based on worst-case interference time for real-time systems
• Xue and others, 2024, An Empirical Study on Modeling Testing Requirements for Safety-Critical Software
• Garanina, 2024, An Exact Schedulability Test for Real-Time Systems with Abstract Scheduler on Multiprocessor Platforms
• Gaujal and others, 2024, An MDP-based solution for the energy minimization of non-clairvoyant hard real-time systems
• Li and others, 2024, Complying with ISO 26262 and ISO/SAE 21434 A Safety and Security Co-Analysis Method for Intelligent Connected Vehicle
• Verdugo and others, 2024, Connecting Research and Practice for Software Product Quality Evaluation and Certification A Software Laboratory’s 25-Year Journey
• Santiago and others, 2024, Development and Simulation of an AUTOSAR Software Component for Functional Safety according to ISO 26262 Fault Detection and Safety Mechanisms
• Wang and others, 2024, Efficient Functional Safety Method for Gate-Level Fine-Grained Digital Circuits with ISO-26262
• Ruh and Craciunas, 2024, End-to-End Schedulability of Virtualized Distributed Time-Triggered Systems
• Panchal and others, 2024, Enhancement of the DO-178C/DO-331 Based Software Verification Framework and Its Practical Application
• Picard and others, 2024, Exact schedulability test for sporadic mixed-criticality real-time systems using antichains and oracles
• BAO and others, 2024, Examining Certification Challenges for Pre-Existing Software-Defined Radio in Safety-Critical Avionics Applications
• Iyenghar, 2024, Exploring the Impact of Dataset Accuracy on Machinery Functional Safety Insights from an AI-Based Predictive Maintenance System
• Pazandak and others, 2024, Fielding Faster Removing Time and Cost Barriers to Software Certification Using Qualifiable Code Generators
• Zhao and others, 2024, FRAP A Flexible Resource Accessing Protocol for Multiprocessor Real-Time Systems
• Thomas, 2024, Future-Proofing Road Safety Adapting ISO 26262 for Advanced V2X Integration
• Sakurai, 2024, Identifying and Rectifying the Potential Faults in the Probabilistic Metric Formula in ISO 26262
• Shanmugam, 2024, ISO 26262 ASIL-B Compliance for AI-Integrated HMI in Commercial Vehicle VCUs
• Konaković and Deljanin, 2024, ISO 26262 Functional Safety Systems for Road Vehicles
• PATHAK and Kothari, 2024, ISO 26262 Functional Safety An Approach for Compliance Readiness
• Okoh and Myklebust, 2024, Mapping to IEC 61508 software developed to ISO 26262
• Okoh and Myklebust, 2024, Mapping to IEC 61508 the hardware safety integrity of elements developed to ISO 26262
• Ali and others, 2024, Modeling and safety analysis for collaborative safety-critical systems using hierarchical colored Petri nets
• Inoue and others, 2024, Optimal Proof-Testing Intervals with Functional Safety Constraint for E/E/PE Safety-Related Systems
• Sullivan and others, 2024, Per-Bank Bandwidth Regulation of Shared Last-Level Cache for Real-Time Systems
• Bhaskar and Kumar, 2024, Predictive Modeling for Real-Time Resource Allocation in Safety Critical Systems
• Rim and others, 2024, Probabilistic Schedulability Analysis with Dependent Execution Times
• Goossens and Masson, 2024, Robust Schedulability Tests for Fixed Job Priorities Addressing Context Switch Costs with Non-Resumable Delays
• Liu and others, 2024, Schedulability Analysis and Performance Optimization for Constrained-Deadline Elastic Tasks
• Ortiz and others, 2024, Schedulability Analysis in Fixed-Priority Real-Time Multicore Systems with Contention
• Alkoudsi and Fohler, 2024, Scheduling Dynamic Task-Sets in Time-Triggered Real-Time Systems
• Onufriev, 2024, SOFTWARE PACKAGE THAT IMPLEMENTS THE FUNCTIONS OF FORMING AN ELECTRONIC ARCHIVE OF THE DEPARTMENTAL CERTIFICATION CENTER
• Lepeeva and Rogov, 2024, Synthesis of ISO 26262 and ISО 21448 methods to increase reliability of hazard analysis and risk assessment of intelligent driver assistance systems operation
• Goh and Anderson, 2024, Towards Principled Budget Enforcement in Real-Time Systems
• Wanner and others, 2024, UAV avionics safety, certification, accidents, redundancy, integrity, and reliability a comprehensive review and future trends
• Hussein and others, 2024, Understanding the Implications Critical Path Analysis vs Dependent Failure Analysis in ISO 26262 Safety Methodology
• Singh and others, 2024, Unified Functional Safety Framework for advance multi-domain SoCs combining ISO 26262 and IEC61508
• Yelisetty and Marques, 2024, Verification Scenarios for Databases in Safety-Critical Systems
• Almeida and others, 2024, Virtualized Fault Injection Framework for ISO 26262-Compliant Digital Component Hardware Faults
• Samimi and others, 2024, Work in Progress Guaranteeing Weakly-Hard Timing Constraints in Server-Based Real-Time Systems
• Pelzer, 2023, 10. Fazit zur Functional Safety Orchestration
• Pelzer, 2023, 5. Konzept Functional Safety Orchestration
• Nabavi and Farbeh, 2023, A fault-tolerant resource locking protocol for multiprocessor real-time systems
• Solouki and others, 2023, A New Approach to Selectively Control Flow Checking Methods Compliant with ISO 26262
• Desai and others, 2023, A Topology-specific Tight Worst-case Analysis of Strict Priority Traffic in Real-time Systems
• Akshay and others, 2023, A Unified Model for Real-Time Systems Symbolic Techniques and Implementation
• Nxumalo and others, 2023, A Verification Tool for Real-Time Task Schedulability Analysis
• Kemper and Laplante, 2023, Addressing Software/Hardware Challenges by Incorporating System Software Integrator Certification
• Zafar and others, 2023, An Empirical Evaluation of System-Level Test Effectiveness for Safety-Critical Software
• Solouki and others, 2023, An Experimental Evaluation of Control Flow Checking for Automotive Embedded Applications Compliant With ISO 26262
• Panchal and others, 2023, Application of a Process-Oriented Build Tool for Verification and Validation of a Battery Slave Controller for a Battery Modular Multilevel Management System Along the DO-178C/DO-331 Process
• Clarke, 2023, Assurance of functional safety
• Paul and others, 2023, Automated DO-178C Compliance Summary through Evidence Curation
• Couadau and others, 2023, Automated Testing of ARINC 661 Cockpit Display Systems Factors to Accelerate DO-178C Certification
• Hubbs and Myren, 2023, Automating Airborne Software Certification Compliance Using Cert DevOps
• Yang and others, 2023, C2AADL_Reverse A Model-Driven Reverse Engineering Approach for Development and Verification of Safety-Critical Software
• Bao and others, 2023, Certification Considerations of Software-Defined Radio Using Model-Based Development and Automated Testing
• Kaber and others, 2023, Considering Severity of Safety-Critical System Outcomes in Risk Analysis An Extension of Fault Tree Analysis
• Milánkovich and Tuma, 2023, Delta Security Certification for Software Supply Chains
• Park and Baek, 2023, Determining rate monotonic schedulability of real-time periodic tasks using continued fractions
• Amalfitano and others, 2023, Documenting Software Architecture Design in Compliance with the ISO 26262 a Practical Experience in Industry
• Albertella, 2023, Engineering safety-critical systems with open-source software
• Baron and Louis, 2023, Framework and tooling proposals for Agile certification of safety-critical embedded software in avionic systems
• Ananda Adhikari and others, 2023, Functional Safety for Automatic Emergency Braking based on ISO 26262
• De Simone and others, 2023, Guest editorial special issue on emerging challenges in software certification and verification
• Mihalj and others, 2023, Hazards Identification Using Scenario-Based Testing with Respect to ISO PAS 21448 and ISO 26262
• Gannous, 2023, Interstices in the Certification of Safety Critical Avionics Software Boeing 737-MAX MCAS Case Study
• Clarke, 2023, Introduction to functional safety
• Clarke, 2023, Key functional safety documents
• Delizonas and others, 2023, Low Complexity and High Safety Architecture of Automotive Li-ion Battery Management Systems in Compliance with the ISO 26262 Standard
• Sun and others, 2023, Minimizing Cache Usage for Real-time Systems
• Hafiz, 2023, Model Based Development Methodology in Compliance with ISO 26262 for Safe Automotive ECU
• Clausing and others, 2023, On Guaranteeing Schedulability of Periodic Real-Time Hardware Tasks Under ReconOS ^ 64
• Beraza and others, 2023, On the Impact of Project Management Certification for Software Projects and Practitioners
• Zhang and others, 2023, Optimal Checkpointing Strategy for Real-time Systems with Both Logical and Timing Correctness
• Jungklass and others, 2023, Predictive Preload at Fixed Preemption Points for Microcontrollers with Hard Real-Time Requirements
• Pop and Igna, 2023, Quality Engineering Framework for Functional Safety Automotive Projects
• Sultana, 2023, REAL-TIME SYSTEMS SCHEDULING AND RESOURCE MANAGEMENT NETWORKING
• Panchal and others, 2023, Real-Time Verification of A Battery Slave Controller Developed Using a DO-178C/DO-331 Based Process-Oriented Build Tool
• 2023, Reform and Practice of Software Engineering Talents Training Program in Application-Oriented Universities Based on Asiin Certification
• Babaarslan and Balcı, 2023, Requirement Based Coverage Analysis in DO-178C Compliant Software Development Projects
• Chen, 2023, Research on Software Test Coverage Analysis Methods Under DO-178C
• Agrawal and others, 2023, Rethinking Tractability for Schedulability Analysis
• Kim, 2023, Scalable Fault Tree Analysis for Functional Safety Software
• Cui and others, 2023, Schedulability Analysis of Rate-Monotonic Algorithm on Concurrent Execution of Digraph Real-Time Tasks
• Nelissen and Pautet, 2023, Special issue on reliable data transmission in real-time systems
• Atsushi, 2023, Stochastic Constituents for the Probabilistic Metric of Random Hardware Failures in ISO 26262
• Holleczek, 2023, The Real-Time Systems Archive
• Peng and others, 2023, The Scheduling Analysis Method of Embedded Real-Time System Based on AADL-IO Annex
• Shan, 2023, Towards DO-178C Compliance of a Secure Product
• Paul and others, 2023, Towards the Certification of Neural Networks using Overarching Properties An Avionics Case Study
• Zlatian and Dreşcă, 2023, Verification and Validation of Safety Critical System Requirements
• Zhao and others, 2023, Work-in-Progress Generating Counter-Examples to Schedulability Using the Schedule Abstraction
• Gharib and others, 2022, A cyber-physical-social approach for engineering Functional Safety Requirements for automotive systems
• Davis and others, 2022, A framework for multi-core schedulability analysis accounting for resource stress and sensitivity
• Reghenzani and others, 2022, A Mixed-Criticality Approach to Fault Tolerance Integrating Schedulability and Failure Requirements
• Sini and others, 2022, A Novel ISO 26262-Compliant Test Bench to Assess the Diagnostic Coverage of Software Hardening Techniques against Digital Components Random Hardware Failures
• Lu and others, 2022, A Quality Evaluation Method for Software Testing about Safety-Critical Software
• Ait Wakrime and Ouhammou, 2022, Advances in modeling, verification and testing of safety-critical software architectures
• Kumar, 2022, An integrated approach of Genetic Algorithm and Machine Learning for generation of Worst-Case Data for Real-Time Systems
• Markovic and others, 2022, Analytical Approximations in Probabilistic Analysis of Real-Time Systems
• Farina and others, 2022, Assessing Intel’s Memory Bandwidth Allocation for resource limitation in real-time systems
• Tran and others, 2022, Assessing the Software Control Autonomy of System Functions in Safety-Critical Systems
• Kaushik and Patel, 2022, Automatic Construction of Predictable and High-Performance Cache Coherence Protocols for Multicore Real-Time Systems
• Khasanov and others, 2022, Automation of software avionics verification in accordance with DO-178C standard
• Reghenzani, 2022, Beyond the Traditional Analyses and Resource Management in Real-Time Systems
• Maier and Mottok, 2022, Causality and Functional Safety - How Causal Models Relate to the Automotive Standards ISO 26262, ISO/PAS 21448, and UL 4600
• Schuster, 2022, Certification of software tools used in safety-critical software development
• Sun and others, 2022, Civil Aircraft Airborne Software Safety and Reliability Study Based on RTCA/DO-178C
• Babaarslan and Topçu, 2022, Code / Model Review Process of Unmanned Aerial Vehicle Software Compliant with DO-178B Certification
• Beyer, 2022, Cooperative Verification Towards Reliable Safety-Critical Systems Invited Talk
• Zhao and others, 2022, Design optimization for real-time systems with sustainable schedulability analysis
• Yang and others, 2022, Development of Harmony-SE Internalization Methodology for Automobile Functional Safety and Cyber Security Process
• Yang and others, 2022, Development of ISO 26262 and ISO 21448 Concept Design Process Integration
• Zhang and others, 2022, Efficient Schedulability Analysis of Hierarchical Real-Time Scheduling with Resource Sharing
• Chaudhari and Baruah, 2022, Efficient Schedulability Analysis of Semi-Clairvoyant Sporadic Task Systems With Graceful Degradation
• Kilian and others, 2022, Emergency Operation in the Power Supply Domain According to ISO 26262
• Dai and others, 2022, Enhanced schedulability tests for real-time regularity-based virtualized systems with dependent and self-suspension tasks
• Atsushi, 2022, Formulas of the Probabilistic Metric for Random Hardware Failures to Resolve a Dilemma in ISO 26262
• Panchal and others, 2022, Handling Complex System Architectures with a DO-178C/DO-331 Process-Oriented Build Tool
• Amurrio and others, 2022, How windows size and number can influence the schedulability of hierarchically-scheduled time-partitioned distributed real-time systems
• Segarra and Marti-Campoy, 2022, Improving the Configuration of the Predictable ACDC Data Cache for Real-Time Systems
• Fizza and others, 2022, Improving the Schedulability of Real-Time Tasks Using Fog Computing
• Gujarati and others, 2022, In-ConcReTeS Interactive Consistency meets Distributed Real-Time Systems, Again!
• Krishna Hema, 2022, Integrated Automotive Software Quality Management System in compliance with Automotive SPICE, ISO 26262, ISO 21448 and ISO 21434 Standards
• Mello and Wainer, 2022, Integrating I-DEVS and schedulability methods for analyzing real-time systems constraints
• Montgomery, 2022, Interface Design for Embedded and Real-Time Systems
• Aceituno and others, 2022, Interference-Aware Schedulability Analysis and Task Allocation for Multicore Hard Real-Time Systems
• Lozovetsky and others, 2022, METHODS AND MEANS OF PROTECTION OF SOFTWARE OF TRANSPORT SYSTEMS DURING CERTIFICATION TESTS
• de la Vara and others, 2022, Model-based assurance evidence management for safety-critical systems
• Russell and others, 2022, Modeling a DO-178C Plan and Analyzing in a Semantic Model
• Salman and others, 2022, Multi-processor scheduling of elastic applications in compositional real-time systems
• Gao and others, 2022, On ISO 26262 Compliance and Safety Assurance for Autonomous Vehicles using STPA
• Bril, 2022, On system models and schedulability analysis for basic single-rate cyclic executives
• Butenko, 2022, Ontology Application in Automating Regulatory Profile Forming for Software Certification
• Zheng, 2022, Real-Time Simulation Support for Real-Time Systems
• Vilela, 2022, Requirements Engineering Maturity Model for Safety-Critical Systems
• Feng, 2022, Research on airworthiness certification of airborne software in civil aircraft compliance verification test
• Vădineanu and Nasri, 2022, Robust and accurate regression-based techniques for period inference in real-time systems
• Lu and Chen, 2022, Safety-Oriented System Hardware Architecture Exploration in Compliance with ISO 26262
• Dong and Liu, 2022, Schedulability Analysis for Coscheduling Real-Time Tasks on Multiprocessors
• Guasque and others, 2022, Schedulability analysis of dynamic priority real-time systems with contention
• Lee, 2022, Schedulability Performance Improvement via Task Split in Real-Time Systems
• Barbareschi and others, 2022, Scrum for safety an agile methodology for safety-critical software systems
• Chen and Shrivastava, 2022, Special issue on practical and robust design of real-time systems
• Wägemann, 2022, Static Worst-Case Analyses and Their Validation Techniques for Safety-Critical Systems
• Kozyrev, 2022, Structural Coverage Analysis of Entry and Exit Points Required to Achieve the Objectives Defined in DO-178C
• Chen and others, 2022, Study on the Application of RTCA/DO-178C in IMA Architecture
• Hampp, 2022, Targeted use of modern high-level languages, reuse of software modules and an ISO 26262 and ISO 21434 compliant compiler tool chain to ensure reliable cooperation guaranteed using all available hardwa
• Shen and others, 2022, TCPS a task and cache-aware partitioned scheduler for hard real-time multi-core systems
• Yoon and others, 2022, TimeDice Schedulability-Preserving Priority Inversion for Mitigating Covert Timing Channels Between Real-time Partitions
• Cioroaica and others, 2022, Timing Model for Predictive Simulation of Safety-critical Systems
• Bandyszak and others, 2022, Uncertainty Theories for Real-Time Systems
• Mamata and Azim, 2022, Work-in-Progress A Resource-Aware Optimization Model for Real-Time Systems Analysis and Design
• Lee and others, 2022, Work-in-Progress Generalized Demand-Based Schedulability Test for Dual-Criticality Sporadic Task Model
• Zhang and others, 2022, Work-in-Progress Optimal Checkpointing Strategy for Real-time Systems with Both Logical and Timing Correctness
• Baek, 2021, A Case Study on the Software Test Criteria Derivation Related with Functional Safety Design/Verification Required to the Software Development with Performance Level Between PLc and PLd for Mobile Machinery
• Björklund and others, 2021, A Comparison of Different Approaches for Verification and Validation of Software in Safety-Critical Systems
• Akesson and others, 2021, A comprehensive survey of industry practice in real-time systems
• Kochanthara and others, 2021, A functional safety assessment method for cooperative automotive architecture
• Guo and others, 2021, A generic approach for the certified schedulability analysis of software systems
• Eito-Brun, 2021, A Proposal for the Tailoring of AUTOSAR Coding Guidelines C++ to ISO 26262-6 2018
• Bendib and others, 2021, A Self-Organized Scheduling Algorithm for Embedded Real-Time Systems
• Demir and Seyfullah Babaarslan, 2021, A Software Verification Approach That Complies with DO-178B Certification Rules on UAV’s Flight Control Computer
• Sun and others, 2021, Airborne Software Development Processes Certification Review Strategy based on RTCA/DO-178C
• da Silva and others, 2021, An automated formal-based approach for reducing undetected faults in ISO 26262 hardware compliant designs
• Elashri and Azim, 2021, An energy-aware optimization model for real-time systems analysis and design
• Elashri and Azim, 2021, An Energy-Efficient Periodic Resource Model for Bounded Delay-Tolerant Real-Time Systems
• Zhen-Hua and others, 2021, Application of PREEvision Software to Realize Vehicle Functional Safety Development
• Yang and others, 2021, C2AADL_Reverse A model-driven reverse engineering approach to development and verification of safety-critical software
• Sun and others, 2021, Calculating Worst-Case Response Time Bounds for OpenMP Programs with Loop Structures
• Durling and others, 2021, Certification Considerations for Adaptive Stress Testing of Airborne Software
• Kuhn, 2021, Combined application of agile practices and functional safety in automotive software development
• Tikar and Ansari, 2021, Compliance of ISO 26262 Safety Standard for Electric Power Steering System
• Singh and others, 2021, Conformance testing of ARINC 653 compliance for a safety critical RTOS using UPPAAL model checker
• Schranner and others, 2021, Deriving a representative variant for the functional safety development according to ISO 26262
• Krampe and Junge, 2021, Deriving functional safety ISO 26262 S-parameters for vulnerable road users from national crash data
• Kaushik and others, 2021, Designing Predictable Cache Coherence Protocols for Multi-Core Real-Time Systems
• Dinkel and others, 2021, Die Rolle der Psychologie in der Sicherheitsvalidierung nach ISO 26262
• Maria Trompouki and Kosmidis, 2021, DO-178C Certification of General-Purpose GPU Software Review of Existing Methods and Future Directions
• Dai and others, 2021, Enhanced Schedulability Tests for Real-Time Regularity-Based Virtualized Systems with Dependent and Self-Suspension Tasks
• Kwon and others, 2021, Flexible Cache Partitioning for Multi-Mode Real-Time Systems
• Haur and others, 2021, Formal schedulability analysis based on multi-core RTOS model
• Zhang and Yong, 2021, Functional safety certification method for in-use escalators
• Cucu-Grosjean and Hu, 2021, Guest editorial Special issue on Real-Time Systems Symposium RTSS
• Lohmann and Tutsch, 2021, Hard Real-Time Memory-Management in a Single Clock Cycle on FPGAs
• Nouri and Warmuth, 2021, IEC 61508 and ISO 26262 A Comparison Study
• Araujo and others, 2021, Implementation and Evaluation of Adaptive Cache Insertion Policies for Real-Time Systems
• El-Bayoumi, 2021, ISO-26262 Compliant Safety-Critical Autonomous Driving Applications Real-Time Interference-Aware Multicore Architectures
• Yadlapalli and Liu, 2021, LAG-Based Analysis Techniques for Scheduling Multiprocessor Hard Real-Time Sporadic DAGs
• Bongirwar, 2021, Leveraging Systems Theoretic Process Analysis STPA for Efficient ISO 26262 Compliance
• Friedmann and Ott, 2021, Linking of ISO 26262 and System-theoretic Process Analysis
• Inoue and others, 2021, Mathematical Approaches in Functional Safety Assessment for E/E/PE Safety-Related Software
• Bechtel and Yun, 2021, Memory-Aware Denial-of-Service Attacks on Shared Cache in Multicore Real-Time Systems
• Kumar and others, 2021, Model Based Verification of Safety-Critical Systems
• Bjelica, 2021, My Big, Fat, Safe Software Stack Functional Safety for Complex Software for Next-Generation Vehicles
• Myklebust and Stålhane, 2021, Plans and Functional Safety Management
• Samarov, 2021, PRACTICAL ISSUES OF CONDUCTING CERTIFICATION TESTS OF SOFTWARE PRODUCTS
• Lee and others, 2021, Real-Time Schedulability Analysis and Enhancement of Transiently Powered Processors With NVMs
• Zhang and others, 2021, Research on Design of Functional Safety Monitoring of Intelligent Driving Vehicle Software Architecture
• Pietzsch, 2021, RISC-V Processor for Network Platforms According to ISO 26262
• Pietzsch, 2021, RISC-V-Prozessor-IP für Netzwerkplattformen nach ISO 26262
• Gliwa, 2021, Safety and ISO 26262
• Gliwa, 2021, Safety, ISO 26262
• Draskovic and others, 2021, Schedulability of probabilistic mixed-criticality systems
• Teixeira and Lima, 2021, Shared resources in multiprocessor real-time systems scheduled by RUN
• Sandgren and Antinyan, 2021, Software Safety Analysis to Support ISO 26262-6 Compliance in Agile Development
• Minaeva and Hanzálek, 2021, Survey on Periodic Scheduling for Time-triggered Hard Real-time Systems
• Gunzel and others, 2021, Suspension-Aware Fixed-Priority Schedulability Test with Arbitrary Deadlines and Arrival Curves
• Dinkel and others, 2021, The Role of Psychology in Safety Validation with ISO 26262
• Gvozdev and Bezhaeva, 2021, The studies of strategies for ensuring the functional safety of hardware and software complexes based on system archetypes and architecture models
• Liu and others, 2021, Tool Qualification Requirements Comparison and Analyses Between RTCA/DO-178B and RTCA/DO-178C+DO-330
• Baron and Louis, 2021, Towards a continuous certification of safety-critical avionics software
• Friedmann and Ott, 2021, Verknüpfung von ISO 26262 und systemtheoretischer Prozessanalyse
• Günzel and others, 2021, Work-in-Progress Evaluation Framework for Self-Suspending Schedulability Tests
• Madala and others, 2021, Workflow between ISO 26262 and ISO 21448 Standards for Autonomous Vehicles
• Ding, 2020, A branch-and-cut approach to examining the maximum density guarantee for pinwheel schedulability of low-dimensional vectors
• Islam and Storer, 2020, A case study of agile software development for safety-Critical systems projects
• Sheikh and Pasha, 2020, A Dynamic Cache-Partition Schedulability Analysis for Partitioned Scheduling on Multicore Real-Time Systems
• Dmitriev and others, 2020, A Lean and Highly-automated Model-Based Software Development Process Based on DO-178C/DO-331
• Mariajoseph and others, 2020, A Physiology-based Driver Readiness Estimation Model for Tuning ISO 26262 Controllability
• Hadley and Standish, 2020, A Practical Assurance Approach for Multi-Cores MCs Within Safety-Critical Software Applications
• Ringdorfer and others, 2020, A Systematical Approach for “System Item Integration and Testing” in Context of ISO 26262
• 2020, AImotive Unveils ISO 26262 Certified Simulator
• Rashid, 2020, An Architecture-centric Approach to Safety Critical Software Product Lines
• Bressan and others, 2020, An ontology-based approach to support the certification of Safety-Critical Software Product Lines
• Zhao and others, 2020, An Optimization Framework for Real-Time Systems with Sustainable Schedulability Analysis
• Cecere and others, 2020, Applying analytical and empirical schedulability analysis techniques to a real spacecraft flight software
• Zhao and others, 2020, Assessing safety-critical systems from operational testing A study on autonomous vehicles
• Jackson, 2020, Certification, Safety, and Software
• Mugarza and others, 2020, Cetratus A framework for zero downtime secure software updates in safety-critical systems
• Pavić and Džapo, 2020, Commentary to An exact schedulability test for fixed-priority preemptive mixed-criticality real-time systems
• Salih and Olawoyin, 2020, Computation of Safety Architecture for Electric Power Steering System and Compliance with ISO 26262
• Lee and Choi, 2020, Constraint-Based Schedulability Analysis in Multiprocessor Real-Time Systems
• Günzel and Chen, 2020, Correspondence Article Counterexample for suspension-aware schedulability analysis of EDF scheduling
• Bongirwar, 2020, Demystifying Functional Safety in Road Vehicles ISO 26262
• Ferlini and others, 2020, Enabling ISO 26262 Compliance with Accelerated Diagnostic Coverage Assessment
• Niu and Rawat, 2020, Energy-Constrained Standby-Sparing for Weakly Hard Real-Time Systems
• Do, 2020, Establishing Measures of ISO 26262 Development Phase for Functional Safety and Reliability Based on Practical Software and System Measurement
• Ballan and others, 2020, Evaluation of ISO 26262 and IEC 61508 metrics for transient faults of a multi-processor system-on-chip through radiation testing
• Bonci and others, 2020, Execution Time of Optimal Controls in Hard Real Time, a Minimal Execution Time Solution for Nonlinear SDRE
• Lee and others, 2020, Exhaustive testing of safety-critical software for reactor protection system
• Gaujal and others, 2020, Feasibility of on-line speed policies in real-time systems
• Yadav and others, 2020, Functional Safety for Braking System through ISO 26262, Operating System Security and DO 254
• Staron, 2020, Functional Safety of Automotive Software
• Bhavana and others, 2020, Functional safety requirements of traction inverter in accordance to ISO 26262
• Pazzaglia and others, 2020, Generalized Weakly Hard Schedulability Analysis for Real-Time Periodic Tasks
• Griffin and others, 2020, Generating Utilization Vectors for the Systematic Evaluation of Schedulability Tests
• Atsushi, 2020, Generic Equations for a Probabilistic Metric for Random Hardware Failures According to ISO 26262
• Berezowski and Haid, 2020, How to Use a Graphical Programming Language in Functional Safety, using the Example of Lab VIEW
• Krampe and Junge, 2020, Injury Severity for Hazard and Risk Analyses Calculation of ISO 26262 S-parameter Values from Real-World Crash Data
• 2020, Iso 26262 Compliance
• Čegiň, 2020, Machine learning based test data generation for safety-critical software
• Heeager and Nielsen, 2020, Meshing agile and plan-driven development in safety-critical software a case study
• Yang and Dong, 2020, Mixed-Criticality Scheduling in Compositional Real-Time Systems with Multiple Budget Estimates
• Sari, 2020, Model-driven Approaches for ISO 26262 Work Products and DFA
• Radlak and others, 2020, Organization of machine learning based product development as per ISO 26262 and ISO/PAS 21448
• Shirazi and others, 2020, Performance maximization of energy-variable self-powered m, k -firm real-time systems
• BEN-AMOR and others, 2020, Probabilistic Schedulability Analysis for Real-time Tasks with Precedence Constraints on Partitioned Multi-core
• Ekberg, 2020, Rate-Monotonic Schedulability of Implicit-Deadline Tasks is NP-hard Beyond Liu and Layland’s Bound
• de Matos and others, 2020, Real-time MTL with durations as SMT with applications to schedulability analysis
• Zheng, 2020, Real-Time Simulation Support for Real-Time Systems
• Martins and Gorschek, 2020, Requirements Engineering for Safety-Critical Systems An Interview Study with Industry Practitioners
• Wang and others, 2020, Safety Argument Pattern Language of Safety-Critical Software
• Zakrzewski and others, 2020, Safety Critical Software Development Methodologies in Avionics
• Torens, 2020, Safety Versus Security in Aviation, Comparing DO-178C with Security Standards
• Sundell and others, 2020, Safety-Critical Software - Quantification of Test Results
• Burns and Davis, 2020, Schedulability Analysis for Adaptive Mixed Criticality Systems with Arbitrary Deadlines and Semi-Clairvoyance
• Kochanthara and others, 2020, Semi-automatic Architectural Suggestions for the Functional Safety of Cooperative Driving Systems
• Odarushchenko and others, 2020, Software Fault Insertion Testing for SIL Certification of Safety PLC-Based System
• Bagheri and others, 2020, Synthesis of assurance cases for software certification
• Özçelik and Altilar, 2020, Test-Driven Approach for Safety-Critical Software Development
• Journalist, 2020, The integrated monitoring software platform for urban rail transit of “Hisense” has passed international safety certification
• Casini and others, 2020, Timing isolation and improved scheduling of deep neural networks for real-time systems
• Gualo and others, 2020, Towards a software quality certification of master data-based applications
• Santos and others, 2020, Towards Automated Evidence Generation for Rapid and Continuous Software Certification
• Pyrgies, 2020, Towards DO-178C certification of adaptive learning UAV agents designed with a cognitive architecture
• Athavale and others, 2020, Trends and Functional Safety Certification Strategies for Advanced Railway Automation Systems
• Bandyszak and others, 2020, Uncertainty Theories for Real-Time Systems
• Hu and others, 2020, VTC A Scheduling Framework Between Soft Real-Time and Hard Real-Time on Multimedia OS
• Baruah, 2020, Work in Progress The ILP-Tractability of Schedulability Analysis Problems
• Peng and others, 2019, A comparison of schedulability analysis methods using state and digraph models for the schedulability analysis of synchronous FSMs
• Souza and others, 2019, A Flexibility Framework for OEM Certification of Software Modifications in Aircraft Systems
• Nag and others, 2019, A Novel Multi-Core Approach for Functional Safety Compliance of Automotive Electronic Control Unit According to ISO 26262
• Guo and others, 2019, A Novel Software Reliability Growth Model of Safety-critical Software Considering Fault Severity Classification
• Mukherjee, 2019, A Novel Test Coverage Metric for Safety-Critical Software
• Paz and El Boussaidi, 2019, A Requirements Modelling Language to Facilitate Avionics Software Verification and Certification
• Schmid and others, 2019, A Safety Argumentation for Fail-Operational Automotive Systems in Compliance with ISO 26262
• Marques and da Cunha, 2019, A Set of Requirements for Certification of Airborne Military Software
• Baumgart and others, 2019, A State-based Extension to STPA for Safety-Critical System-of-Systems
• Baek and others, 2019, A Study for HARA of Smart Break System of Construction Equipment based on ISO 26262
• Baek, 2019, A Study on the Method of Functional Safety Design/Verification/Validation and Conformity Declaration Process in Accordance with EU Machinery Directive
• Do, 2019, A Study on the Performing of Safety Analysis of ISO 26262 Development Phase Applying STPA Based on STAMP
• Wei, 2019, AADL-Based Safety Analysis Approaches for Safety-Critical Systems
• Prashanth Reddy and others, 2019, Achieving ISO 26262 and IEC 61508 objectives with a common development process
• Dong and Liu, 2019, An Efficient Utilization-Based Test for Scheduling Hard Real-Time Sporadic DAG Task Systems on Multiprocessors
• Yalcinkaya and others, 2019, An Exact Schedulability Test for Non-Preemptive Self-Suspending Real-Time Tasks
• Youssef, 2019, An Online Algorithm Enabling Authentication and Integrity for Real-Time Systems
• Larrucea and others, 2019, Analysing encryption mechanisms and functional safety in a ROS-based architecture
• Hochstrasser and others, 2019, Application of a Process-Oriented Build Tool for Flight Controller Development Along a DO-178C/DO-331 Process
• Dhaked and others, 2019, Application of Concept Phase to Design an Electric Powertrain in Compliance with ISO 26262
• Tabani and others, 2019, Assessing the Adherence of an Industrial Autonomous Driving Framework to ISO 26262 Software Guidelines
• Sarac, 2019, Certification Aspects of Model Based Development for Airborne Software
• Zeitler, 2019, Challenges of certification and integration of new hardware into legacy avionics architectures
• Radack and others, 2019, Civil Certification of Multi-core Processing Systems in Commercial Avionics
• Muts and others, 2019, Compiler-Based Code Compression for Hard Real-Time Systems
• Debbech and others, 2019, Conceptual Modelling of the Dynamic Goal-oriented Safety Management for Safety Critical Systems
• Falk and Lokuciejewski, 2019, Correction to A compiler framework for the reduction of worst-case execution times
• Hahn and Reineke, 2019, Design and analysis of SIC a provably timing-predictable pipelined processor core
• Yi, 2019, Design and Dynamic Update of Real-Time Systems
• Serban, 2019, Designing Safety Critical Software Systems to Manage Inherent Uncertainty
• Kildishev and Khoroshilov, 2019, Developing Requirements Management Tool for Safety-Critical Systems
• Novikov and Sazonov, 2019, Digital certification of aviation equipment on the basis of “Siemens PLM Software” technologies
• Erciyes, 2019, Distributed Real-Time Systems
• Kirovskii and Gorelov, 2019, Driver assistance systems analysis, tests and the safety case. ISO 26262 and ISO PAS 21448
• Gowda, 2019, ECU Inter-processor data communication End to End verification in Autosar for achieving Functional Safety Goals
• 2019, Embedded and Real-time Systems
• Srinivasan and others, 2019, Empirical Bounds of Multicore Cache Interference for Real-Time Schedulability Analysis
• Donnarumma and others, 2019, EN-50128 Certification-Oriented Design of a Safety-Critical Hard Real-Time Kernel
• Johansson and others, 2019, Enabling Efficient Functional Safety Audits - The Missing Link between ISO 26262 and Automotive SPICE
• El Ghor and Chetto, 2019, Energy Guarantee Scheme for Real-time Systems with Energy Harvesting Constraints
• Khare and others, 2019, Enhanced Schedulability via Minimal Routing with Mapping and Priority Assignment for Real-Time Network-on-chip
• Tiedeman and Parkinson, 2019, Experiences of Civil Certification of Multi-Core Processing Systems in Commercial and Military Avionics, Integration Activities, and Analysis
• Athavale and others, 2019, Flight Safety Certification Implications for Complex Multi-Core Processor Based Avionics Systems
• Jharko, 2019, Functional Safety of Software Systems Important for NPP Safety
• Puaut, 2019, Guest editorial special issue on the Real-Time Systems Symposium 2017
• Pourmohseni and others, 2019, Hard real-time application mapping reconfiguration for NoC-based many-core systems
• Armstrong and Pissoort, 2019, Hardware and Software Techniques and Measures to Effectively Manage EMI Functional Safety Risks
• Xu and others, 2019, Holistic Resource Allocation for Multicore Real-Time Systems
• Besker and others, 2019, How Regulations of Safety-Critical Software Affect Technical Debt
• Alluri and others, 2019, Hybrid emulation approach in ISO 26262 compliant unit test process
• Kumar and Tyagi, 2019, Implementation and Comparative Analysis of k-means and Fuzzy c-means Clustering Algorithms for Tasks Allocation in Distributed Real Time System
• Lidstrom and others, 2019, Improved Pattern for ISO 26262 ASIL Decomposition with Dependent Requirements
• Baek and Lee, 2019, Improved schedulability analysis of the contention-free policy for real-time systems
• Kadeed and others, 2019, Integrated Energy Control for Hard Real-Time Networks-on-Chip
• Guo and others, 2019, Integrating Formal Schedulability Analysis into a Verified OS Kernel
• Gannous and Andrews, 2019, Integrating Safety Certification Into Model-Based Testing of Safety-Critical Systems
• Erciyes, 2019, Introduction to Real-Time Systems
• Lu and Chen, 2019, ISO 26262 ASIL-Oriented Hardware Design Framework for Safety-Critical Automotive Systems
• Kumar, 2019, ISO 26262 Hazard and Risk Assessment for Hybrid Powertrain
• Turin, 2019, Model-Based Software Development Functional Safety Compliance via Built-In Tool Intelligence
• Metayer and others, 2019, Modelling DO-178C Assurance Needs A Design Assurance Level-Sensitive DSL
• Jadhav and Falk, 2019, Multi-Objective Optimization for the Compiler of Real-Time Systems based on Flower Pollination Algorithm
• Athavale and others, 2019, Notice of Retraction Flight Safety Certification Implications for Complex Multi-Core Processor based Avionics Systems
• Debouk, 2019, Overview of the Second Edition of ISO 26262 Functional Safety Road Vehicles
• Sundell and others, 2019, Prediction of Undetected Faults in Safety-Critical Software
• Hassan, 2019, Reduced latency DRAM for multi-core safety-critical real-time systems
• Jungić and others, 2019, Safety in Automotive Industry ISO 26262 Compliant Unit Testing
• Luo and others, 2019, Safety-Driven Development and ISO 26262
• Fonseca and others, 2019, Schedulability analysis of DAG tasks with arbitrary deadlines under global fixed-priority scheduling
• AHSAN and OĞUZTÜZÜN, 2019, Schedulability analysis of real-time multiframe cosimulations on multicore platforms
• Blazewicz and others, 2019, Scheduling in Hard Real-Time Systems
• Schlüter and others, 2019, Schnittstellen zwischen der KAUSAL Methodik und der Funktionalen Sicherheit nach ISO 26262
• Oshana, 2019, Software Engineering for Embedded and Real-Time Systems
• Erciyes, 2019, Software Engineering of Real-Time Systems
• Anand and others, 2019, Software Patch Scheduling Policy Incorporating Functional Safety Standards
• Lohmüller and Bauer, 2019, Software Product Line Engineering for Safety-critical Systems
• Bharathi R and Selvarani R, 2019, Software Reliability Assessment of Safety Critical System Using Computational Intelligence
• Ivanov and others, 2019, Software Structure, Program Generation and Schedulability Analysis of Extracorporeal Perfusion Pump Embedded Controller
• Paz and El Boussaidi, 2019, Supporting Consistency in the Heterogeneous Design of Safety-Critical Software
• Dziurzanski and others, 2019, Synthesizing Real-Time Schedulability Tests using Evolutionary Algorithms A Proof of Concept
• Palamut and others, 2019, Task Scheduling Algorithms and Resource Access Protocols in Real Time Systems
• Zhao and Zeng, 2019, The concept of Maximal Unschedulable Deadline Assignment for optimization in fixed-priority scheduled real-time systems
• Khan, 2019, Thermal-Aware Real-Time Task Schedulabilty test for Energy and Power System Optimization using Homogeneous Cache Hierarchy of Multi-core Systems
• Perez Rodriguez and Meumeu Yomsi, 2019, Thermal-Aware Schedulability Analysis for Fixed-Priority Non-preemptive Real-Time Systems
• Nam and others, 2019, Tight Evaluation of Real-Time Task Schedulability for Processor’s DVS and Nonvolatile Memory Allocation
• O’Regan, 2019, Verification of Safety-Critical Systems
• Biondi and others, 2018, A design flow for supporting component-based software development in multiprocessor real-time systems
• Saberi and others, 2018, A method for quantitative measurement of safety culture based on ISO 26262
• Chonnad and others, 2018, A Quantitative Approach to SoC Functional Safety Analysis
• Han and Park, 2018, A Study on Integrated Airworthiness Certification Criteria for Avionics Software Safety and Security
• Salay and others, 2018, An Analysis of ISO 26262 Machine Learning and Safety in Automotive Software
• Jung and Min, 2018, An Integrated Analysis Method Considering Security in ISO 26262 for Improving the Safety of the Vehicle
• Dong and Liu, 2018, Analysis techniques for supporting hard real-time sporadic gang task systems
• Gosavi and others, 2018, Application of Functional Safety in Autonomous Vehicles Using ISO 26262 Standard A Survey
• Schwierz and Forsberg, 2018, Assurance Benefits of ISO 26262 Compliant Microcontrollers for Safety-Critical Avionics
• Trilla and others, 2018, Cache Side-Channel Attacks and Time-Predictability in High-Performance Critical Real-Time Systems
• Kleyner and Knoell, 2018, Calculating Probability Metric for Random Hardware Failures PMHF in the New Version of ISO 26262 Functional Safety - Methodology and Case Studies
• Batuwangala and others, 2018, Certification challenges for next-generation avionics and air traffic management systems
• 2018, Certification of Civil Avionics
• Streitferdt and others, 2018, Complete Component-Wise Software Certification for Safety-Critical Embedded Devices
• Boudjadar, 2018, Compositional Schedulability Analysis of Multicore Modular Avionic Architectures
• Lee and Choi, 2018, Constraint Solving Approach to Schedulability Analysis in Real-Time Systems
• Gujarati and others, 2018, Correspondence article a correction of the reduction-based schedulability analysis for APA scheduling
• Walker, 2018, Cybersecurity in safety-critical systems
• D’souza and Rajkumar, 2018, CycleTandem Energy-Saving Scheduling for Real-Time Systems with Hardware Accelerators
• Gvozdev and others, 2018, Decision Support in Management of Hardware-Software Complex Functional Safety on the Basis of Ontological Engineering
• Hahn and Reineke, 2018, Design and Analysis of SIC A Provably Timing-Predictable Pipelined Processor Core
• Klaasse and others, 2018, Development of a Functional Safety Software Layer for the Control of an Electric In-Wheel Motor Based Powertrain
• Schmidt and others, 2018, Dynamic Resource Allocation of Switched Ethernet Networks in Embedded Real-Time Systems
• Gundersen and others, 2018, Effortless Fault Localisation Conformance Testing of Real-Time Systems in Ecdar
• Xu and others, 2018, Energy-efficient scheduling with reliability guarantee in embedded real-time systems
• Intrigila and Mazzucchelli, 2018, Engineering Complex Safety Critical Software Systems Abstraction and Concreteness
• Seifert and others, 2018, Entwicklungsvorschläge für ISO 26262 konforme MCUs in sicherheitskritischer Avionik
• Odarushchenko and others, 2018, Fault insertion software and hardware testing for safety PLC-based system SIL certification
• Nasri and others, 2018, FIFO with Offsets High Schedulability with Low Overheads
• Grilo and Lopes, 2018, Formalization and Certification of Software for Smart Cities
• Wang, 2018, From Predicate Testing to Identify Fault Location for Safety-Critical Software
• Schrage and others, 2018, Functional Safety Management Approach for Certification of Evolving eVTOL Air Taxi Concepts
• 2018, Fundamentals of functional safety
• Lee and others, 2018, Hardware-in-the-Loop Test Case Specification for Verification of Software Safety Requirements in the Context of ISO 26262
• Steinmann, 2018, IFC Certification of BIM Software
• Łukasiewicz and Górski, 2018, Introducing agile practices into development processes of safety critical software
• Lohmüller and others, 2018, Multi-Concerns Engineering for Safety-Critical Systems
• Muts and others, 2018, Multi-Criteria Compiler-Based Optimization of Hard Real-Time Systems
• Bouaziz and others, 2018, Multi-objective design exploration approach for Ravenscar real-time systems
• Schildbach, 2018, On the Application of ISO 26262 in Control Design for Automated Vehicles
• Verenikina and others, 2018, Quality Management System Certification in the Russian Software Development Industry
• 2018, Real-Time Systems
• Han and others, 2018, Resource-aware partitioned scheduling for heterogeneous multicore real-time systems
• Yamasaki and others, 2018, Responsive Multithreaded Processor for Hard Real-Time Robotic Applications
• Pietrantuono and Russo, 2018, Robotics Software Engineering and Certification Issues and Challenges
• 2018, RTCA DO-178B/EUROCAE ED-12B
• 2018, RTCA DO-297/EUROCAE ED-124 Integrated Modular Avionics IMA Design Guidance and Certification Considerations
• Chaya Addagarrala and Kinnicutt, 2018, Safety critical software ground rules
• Douthwaite and Kelly, 2018, Safety-Critical Software and Safety-Critical Artificial Intelligence Integrating New Practices and New Safety Concerns for AI systems
• Gu and others, 2018, Safety-Related Component for CNC System A Case of Functional Safety in Software Application
• Kozyrev and Saburov, 2018, Satisfying DO-178C Structural Coverage Objectives
• Abdullah and others, 2018, Schedulability Analysis and Software Synthesis for Graph-Based Task Models with Resource Sharing
• Dongre and Mahajan, 2018, Schedulability Analysis for Multiresource Scheduling in Middleware for Distributed Real Time Systems
• Peng and others, 2018, Schedulability Analysis of Adaptive Variable-Rate Tasks with Dynamic Switching Speeds
• Xu and others, 2018, Schedulability Analysis of Graph-Based Real-Time Task Model with Precedence Constraints
• Mashkoor and others, 2018, Selected functional safety and cybersecurity concerns in system, software, and service process improvement and innovation
• Kawakoshi and others, 2018, Simulation Techniques for Determining Motorcycle Controllability Class according to ISO 26262
• Marques and da Cunha, 2018, Tailoring Traditional Software Life Cycles to Ensure Compliance of RTCA DO-178C and DO-331 with Model-Driven Design
• Kassab, 2018, Testing Practices of Software in Safety Critical Systems Industrial Survey
• Gannous and others, 2018, Toward a Systematic and Safety Evidence Productive Verification Approach for Safety-Critical Systems
• Boudjadar and Macedo, 2018, Towards a Schedulability-driven Architecture Exploration for Mixed Criticality Multicore Systems
• Sini and others, 2018, Towards an automatic approach for hardware verification according to ISO 26262 functional safety standard
• Geist and others, 2018, Towards functional safety and security for adaptive and flexible business processes
• Geismann, 2018, Traceable Threat Modeling for Safety-Critical Systems
• Rashid and others, 2018, Trading Between Intra- and Inter-Task Cache Interference to Improve Schedulability
• Lucas and others, 2018, VOSYSmonitor, a TrustZone-based Hypervisor for ISO 26262 Mixed-critical System
• Hanssen and others, 2018, What Is Safety-Critical Software?
• Xia and others, 2018, Work-in-Progress Preference-Oriented Scheduling in Multiprocessor Real-Time Systems
• Ismail and Jawawi, 2017, A Hybrid Multiprocessor Scheduling Approach for Weakly Hard Real-Time Tasks
• Mendoza and Capel, 2017, A methodological approach for checking safety-critical systems software
• Tong and Lei, 2017, A Systematic Analysis of Functional Safety Certification Practices in Industrial Robot Software Development
• Valsan and others, 2017, Addressing isolation challenges of non-blocking caches for multicore real-time systems
• Zhao and Zeng, 2017, An efficient schedulability analysis for optimizing systems with adaptive mixed-criticality scheduling
• Asyaban and Kargahi, 2017, An exact schedulability test for fixed-priority preemptive mixed-criticality real-time systems
• Dong and Liu, 2017, Analysis Techniques for Supporting Hard Real-Time Sporadic Gang Task Systems
• Mohan and others, 2017, ATRIUM Architecting under uncertainty For ISO 26262 compliance
• Völker and Stadie, 2017, Auswirkungen der ISO 26262 aufNutzfahrzeug und Lenksystem
• Granig and others, 2017, Calculation of Failure Detection Probability on Safety Mechanisms of Correlated Sensor Signals According to ISO 26262
• Biscoglio and others, 2017, Certification of Cash Registers Software
• McCormick, 2017, Certification of Civil Avionics
• Schiller, 2017, Certification of Externally Developed Software
• Jiménez and others, 2017, Checklists for compliance to DO-178C and DO-278A standards
• Tabassam and Obermaisser, 2017, Class-based query-optimization for minimizing worst-case execution times of diagnostic queries in embedded real-time systems
• Streitferdt and others, 2017, Component-wise software certification for safety-critical embedded devices
• 2017, Correction Hard real-time closed-loop electrophysiology with the Real-Time eXperiment Interface RTXI
• Boucheneb and Barkaoui, 2017, Delay-dependent partial order reduction technique for real time systems
• Frese and others, 2017, Deriving Safety Requirements according to ISO 26262 for complex systems A method applied in the automotive industry
• Hasegawa and Kaneko, 2017, Detailed Study of Hazard Analysis and Risk Assessment of ISO 26262 for Motorcycles
• Griessnig and Schnellbach, 2017, Development of the 2nd Edition of the ISO 26262
• Varma and others, 2017, DTLB Deterministic TLB for Tightly Bound Hard Real-Time Systems
• Alexandrescu and others, 2017, EDA support for functional safety How static and dynamic failure analysis can improve productivity in the assessment of functional safety
• Völker and Stadie, 2017, Effects of ISO 26262 on Commercial Vehicle and Steering System
• Gu and Easwaran, 2017, Efficient Schedulability Test for Dynamic-Priority Scheduling of Mixed-Criticality Real-Time Systems
• Mucha and others, 2017, Estimation of Worst Case Response Time boundaries in multi-core real-time systems
• Castillo and others, 2017, Execution time distributions in embedded safety-critical systems using extreme value theory
• ZHANG, 2017, Experimental Evaluation of a New Schedulability Test Algorithm QCSP-SchTest2 for Preemptive Real-time Scheduling Problem
• Ekberg and Yi, 2017, Fixed-Priority Schedulability of Sporadic Tasks on Uniprocessors is NP-Hard
• Kalia, 2017, FRAMEWORK FOR CERTIFICATION OF REUSABLE SOFTWARE COMPONENTS
• Staron and Johannessen, 2017, Functional Safety of Automotive Software
• Reinbold, 2017, Gefährdungsanalyse und Risikobeurteilung U Becker nach ISO 26262 am Beispiel eines induktiven Valet Charging Systems
• Jung and Lee, 2017, Improved Schedulability Analysis of Fixed-Priority for Mixed-Criticality Real-Time Multiprocessor Systems
• Roseberry and Scott-Parry, 2017, Improvement of airworthiness certification audits of software-centric avionics systems using a cross-discipline application lifecycle management system methodology
• Young and Walker, 2017, Improvements in Functional Safety of Automotive IP Through ISO 26262 2018 Part 11
• Kennedy and Towhidnejad, 2017, Innovation and certification in aviation software
• Suo and others, 2017, Integrating STPA into ISO 26262 Process for Requirement Development
• Maier-Komor and others, 2017, ISO 26262 at BMW Motorrad More Than Just Safety
• Maier-Komor and others, 2017, ISO 26262 bei BMW Motorrad Mehr als nur Sicherheit
• Sargsyan, 2017, ISO 26262 compliant memory BIST architecture
• Khan, 2017, ISO 26262 system level functional safety validation for battery management systems in automobiles
• Anderson, 2017, Mehr Softwaresicherheit Statische Analysetools und die ISO 26262
• Sari and Reuss, 2017, Model-based Development of Safety-critical Functions and ISO 26262 Work Products using modified EAST-ADL
• Dziurzanski and others, 2017, Multi-criteria resource allocation in modal hard real-time systems
• Zhao and others, 2017, New schedulability analysis for MrsP
• Nasri and Brandenburg, 2017, Offline Equivalence A Non-preemptive Scheduling Technique for Resource-Constrained Embedded Real-Time Systems Outstanding Paper
• Doerr and others, 2017, On the Impact of the Second Edition of the ISO 26262 on Model-Based Development of Safety-Related Systems
• Bhatt and others, 2017, Opportunities and challenges for formal methods tools in the certification of avionics software
• 2017, Overview of DO-178C and Supporting Documents
• Peng and Fisher, 2017, Parameter adaptation for generalized multiframe tasks schedulability analysis, case study, and applications to self-suspending tasks
• Gallina and Nyberg, 2017, Pioneering the Creation of ISO 26262-Compliant OSLC-Based Safety Cases
• Hassan and others, 2017, Predictable Cache Coherence for Multi-core Real-Time Systems
• Chowdhury and others, 2017, Principles for Systematic Development of an Assurance Case Template from ISO 26262
• Abdeddaim and Maxim, 2017, Probabilistic schedulability analysis for fixed priority mixed criticality real-time systems
• Niu and others, 2017, Reliability-Aware Energy Management for Embedded Real-Time Systems with m, k -Hard Timing Constraint
• Martins and Gorschek, 2017, Requirements Engineering for Safety-Critical Systems Overview and Challenges
• Wang, 2017, Research on the Execution Time Analysis Technology of the Worst Case System in Real Time System
• Abdi and others, 2017, Restart-based fault-tolerance System design and schedulability analysis
• Guarro and others, 2017, Risk Informed Safety Case Framework for Unmanned Aircraft System Flight Software Certification
• Johnsen and others, 2017, Risk-Based Decision-Making Fallacies Why Present Functional Safety Standards are Not Enough
• Ferrell and Ferrell, 2017, RTCA DO-178B/ EUROCAE ED-12B
• Ferrell and Ferrell, 2017, RTCA DO-178C/EUROCAE ED-12C and the Technical Supplements
• Spitzer and Rierson, 2017, RTCA DO-297/EUROCAE ED-124 Integrated Modular Avionics IMA Design Guidance and Certification Considerations
• Kumar and others, 2017, Safety Analysis of Safety-Critical Systems Using State-Space Models
• Al Eidi and Alkandari, 2017, Safety Critical Software Development A Modeling Approach
• Wang, 2017, Schedulability Analysis and Symbolic Verification Method for Heterogeneous Multicore Real-Time Systems
• Bertolotti and Manduchi, 2017, Schedulability Analysis Based on Response Time Analysis
• Bertolotti and Manduchi, 2017, Schedulability Analysis Based on Utilization
• Hua and others, 2017, Schedulability Analysis for Real-Time Task Set on Resource with Performance Degradation and Dual-Level Periodic Rejuvenations
• Ashjaei and others, 2017, Schedulability analysis of Ethernet Audio Video Bridging networks with scheduled traffic support
• Goradia and Shah, 2017, Schedulability analysis of globally scheduled multiprocessor schedulers for real time system A Review
• Xiao and others, 2017, Schedulability Analysis of Non-preemptive Real-Time Scheduling for Multicore Processors with Shared Caches
• Pepi and Fantechi, 2017, Schedulability Analysis of Pre-runtime and Runtime Scheduling Algorithm of an Industrial Real Time System
• Boudjadar and Nadjm-Tehrani, 2017, Schedulability and Memory Interference Analysis of Multicore Preemptive Real-time Systems
• Luppold and Falk, 2017, Schedulability-aware SPM Allocation for preemptive hard real-time systems with arbitrary activation patterns
• Bertolotti and Manduchi, 2017, Self-Suspension and Schedulability Analysis
• Ferreira, 2017, Software Certification in Practice How Are Standards Being Applied?
• Kedar and others, 2017, SPACE Semi-Partitioned CachE for Energy Efficient, Hard Real-Time Systems
• Gallina and Natella, 2017, Special section on Reliability and Safety Certification of Software-Intensive Systems
• Dietrich and others, 2017, SysWCET Whole-System Response-Time Analysis for Fixed-Priority Real-Time Systems Outstanding Paper
• Hanssen and others, 2017, Trends in agile development of safety-critical software
• Sweeney, 2017, Understanding the Role of RTCA DO-160 in the Avionics Certification Process
• Liu and others, 2017, Using non-preemptive regions and path modification to improve schedulability of real-time traffic over priority-based NoCs
• Marques and Marques da Cunha, 2017, Verification scenarios of onboard databases under the RTCA DO-178C and the RTCA DO-200B
• Sun and Natale, 2017, Weakly Hard Schedulability Analysis for Fixed Priority Scheduling of Periodic Real-Time Tasks
• Guo and others, 2017, Work-in-Progress Cache-Aware Partitioned EDF Scheduling for Multi-core Real-Time Systems
• Ismail and others, 2017, Work-in-Progress Utilization Based Schedulability Analysis for Wireless Sensor-Actuator Networks
• Dias and others, 2016, A Cache Design Assessment Approach for Embedded Real-Time Systems Based on Execution Time Measurement
• Dion, 2016, A Cost-Effective Model-Based Approach for Developing ISO 26262 Compliant Automotive Safety Related Applications
• Navarro and others, 2016, A dynamic cache reconfiguration platform for soft real-time systems
• Zhang, 2016, A Novel Schedulability Test Algorithm for Preemptive Real-Time Scheduling Problem in QCSP
• Frieb and others, 2016, A Parallelization Approach for Hard Real-Time Systems and Its Application on Two Industrial Programs
• Jordan and others, 2016, A Software Managed Stack Cache for Real-Time Systems
• Schoeberl and Nielsen, 2016, A Stack Cache for Real-Time Systems
• Lin and others, 2016, An Amanat-Based Multi-party Certification Protocol for Outsourced Software in Automotive Systems
• Alrashed and others, 2016, An efficient schedulability condition for non-preemptive real-time systems at common scheduling points
• Trei and others, 2016, An ISO 26262 Compliant Design Flow and Tool for Automotive Multicore Systems
• Belschner and others, 2016, Automated generation of certification relevant documentation for a distributed avionics platform approach
• Weissnegger and others, 2016, Automatic Testbench Generation for Simulation-based Verification of Safety-critical Systems in UML
• Mohamed Darwish, 2016, Bio-Inspired Intelligent System for Software Quality Certification
• Wang and others, 2016, Cache-Aware Cooperative Task Mapping in Multi-core Real-Time Systems
• Luppold and others, 2016, Cache-Aware Instruction SPM Allocation for Hard Real-Time Systems
• Phan and others, 2016, Cache-aware interfaces for compositional real-time systems
• 2016, Certification, Safety, and Software
• Bowman and others, 2016, Closing The Loop Testing for IM Avionics Certification
• Jaghoori and others, 2016, Compositional schedulability analysis of real-time actor-based systems
• Ross, 2016, Confirmation of Functional Safety
• 2016, Designing Real-Time and Distributed Real-Time Systems
• Janarthanan, 2016, Designing Schedulers for Hard Real-Time Tasks
• 2016, Developing Distributed Real-Time System Applications-the MATLAB Way
• 2016, Distributed Real-Time Systems
• Rowanhill and Knight, 2016, Domain Arguments in Safety Critical Software Development
• Biscoglio and others, 2016, Fiscal Software Certification - An Italian Experience of Certification Against the Fiscal Legislation
• Klos and others, 2016, Formal Models for Analysing Dynamic Adaptation Behaviour in Real-Time Systems
• Magdich and others, 2016, From UML/MARTE Models of Multiprocessor Real-time Embedded Systems to Early Schedulability Analysis based on SimSo Tool
• Nause and Höwing, 2016, Functional Safety as a Paradigm Software Development in Automotive Security
• Baumgart and Froberg, 2016, Functional Safety in Product Lines – A Systematic Mapping Study
• Martin and others, 2016, Functional Safety of Automated Driving Systems Does ISO 26262 Meet the Challenges?
• Hestermeyer, 2016, FUNCTIONAL SAFETY Sicherheitsrelevante Inhouse-Software-Entwicklung bei Ford Steering Safety-relevant in-house software development at Ford Steering
• Schrage and Arterburn, 2016, Future Vertical Lift Airworthiness Certification - Should it be based on A Civil Aviation Functional Safety Certification Standard?
• Gu and others, 2016, Improving computation efficiency of schedulability of transaction-based task model for distributed real-time embedded systems
• Trilla and others, 2016, Improving Early Design Stage Timing Modeling in Multicore Based Real-Time Systems
• Fleming and others, 2016, Improving the Schedulability of Mixed Criticality Cyclic Executives via Limited Task Splitting
• 2016, Introduction to Real-Time Systems
• Jian, 2016, Introductory Chapter Real-Time Systems
• Chen and others, 2016, k2Q A Quadratic-Form Response Time and Schedulability Analysis Framework for Utilization-Based Analysis
• Doerr and Stuermer, 2016, Managing an ISO 26262 Safety Case A Software System Perspective
• Russo and Scippacercola, 2016, Model-Based Software Engineering and Certification Some Open Issues
• Grant and Datta, 2016, Modeling RTCA DO-178C Specification to Facilitate Avionic Software System Design, Verification, and Validation
• Ahmed and others, 2016, Necessary and Sufficient Conditions for Thermal Schedulability of Periodic Real-Time Tasks Under Fluid Scheduling Model
• Eisemann and Allen, 2016, New Requirement-Definition and Verification Techniques According to DO-178C, DO-331, and DO-333
• Mohaqeqi and others, 2016, On Fixed-Priority Schedulability Analysis of Sporadic Tasks with Self-Suspension
• Altmeyer and others, 2016, On the effectiveness of cache partitioning in hard real-time systems
• Paz and El Boussaidi, 2016, On the Exploration of Model-Based Support for DO-178C-Compliant Avionics Software Development and Certification
• Fantechi and Pepi, 2016, Petri Nets Modeling for the Schedulability Analysis of Industrial Real Time Systems
• Graydon and Holloway, 2016, Planning the Unplanned Experiment Towards Assessing the Efficacy of Standards for Safety-Critical Software
• Cotroneo and others, 2016, Prediction of the Testing Effort for the Safety Certification of Open-Source Software A Case Study on a Real-Time Operating System
• Deutschbein and Baruah, 2016, Preemptive Uniprocessor EDF Schedulability Analysis with Preemption Costs Considered
• Hanssen and others, 2016, Proceedings on the 1st Workshop on Agile Methods Applied to Development and Certification of Safety-critical Software
• Pawar, 2016, Progressive Worst Case Scenario Analysis Improving Functional Safety by Bridging Gaps in FMEA for Effective Implementation of ISO 26262
• Das and Taylor, 2016, Quantified fault tree techniques for calculating hardware fault metrics according to ISO 26262
• Nasri and others, 2016, Quantifying the Effect of Period Ratios on Schedulability of Rate Monotonic
• Massa and others, 2016, Quasi-partitioned scheduling optimality and adaptation in multiprocessor real-time systems
• Pathan, 2016, Real-time scheduling algorithm for safety-critical systems on faulty multicore environments
• Fan, 2016, Real-Time Systems
• Martins and Gorschek, 2016, Requirements engineering for safety-critical systems A systematic literature review
• Arai and others, 2016, Research on Severity Class Evaluation Based on Various Crash Situations Involved with Motorcycles for ISO 26262
• Trilla and others, 2016, Resilient random modulo cache memories for probabilistically-analyzable real-time systems
• Barros and others, 2016, Response time analysis of hard real-time tasks sharing software transactional memory data under fully partitioned scheduling
• Kochanthara and others, 2016, REVERT Runtime Verification for Real-Time Systems
• Haririan and Garcia-Ortiz, 2016, Run-time schedulability check of real-time tasks for energy efficiency
• Jiang and others, 2016, Safety analysis for safety-critical system based on boilerplate and Alloy
• Baruah, 2016, Schedulability Analysis for a General Model of Mixed-Criticality Recurrent Real-Time Tasks
• Yao and others, 2016, Schedulability Analysis for Memory Bandwidth Regulated Multicore Real-Time Systems
• Ben-Amor and others, 2016, Schedulability analysis of dependent probabilistic real-time tasks
• Biondi and others, 2016, Schedulability Analysis of Hierarchical Real-Time Systems under Shared Resources
• Baruah, 2016, Schedulability analysis of mixed-criticality systems with multiple frequency specifications
• Zagan and Gaitan, 2016, Schedulability analysis of nMPRA processor based on multithreaded execution
• Mohaqeqi and others, 2016, Schedulability Analysis of Synchronous Digraph Real-Time Tasks
• Chuang and others, 2016, Scheduling Low-Utilized Real-Time Systems with End-to-End Timing Constraints
• 2016, Sigma and 3DSIM to develop software for AM certification
• 2016, Simulation-based Schedulability Assessment for Real-Time Systems
• Basagiannis, 2016, Software certification of airborne cyber-physical systems under DO-178C
• Bukowski and others, 2016, Software functional safety Possibilities and limitations of IEC61508-7 Annex D
• Paula and others, 2016, Software product certification An academic-industry certification project
• Gabriška, 2016, Software requirements for the control systems according to the level of functional safety
• Darwish, 2016, Software test quality rating A paradigm shift in swarm computing for software certification
• Ernst, 2016, Special issue of the Euromicro Conference on Real-Time Systems ECRTS
• Evans, 2016, System software quality assurance for safety critical systems
• Yoon and others, 2016, TaskShuffler A Schedule Randomization Protocol for Obfuscation against Timing Inference Attacks in Real-Time Systems
• Axelrod, 2016, The creation and certification of software cybersecurity standards
• Pérez and others, 2016, The Polling Effect on the Schedulability of Distributed Real-Time Systems
• Gallina and others, 2016, Towards an ISO 26262-compliant OSLC-based Tool Chain Enabling Continuous Self-Assessment
• Rahimi, 2016, Trace link evolution across multiple software versions in safety-critical systems
• Gu and others, 2016, Transforming Real-Time Task Graphs to Improve Schedulability
• van den Heuvel and others, 2016, Uniform Interfaces for Resource-Sharing Components in Hierarchically Scheduled Real-Time Systems
• Liu and others, 2016, Using segmentation to improve schedulability of real-time traffic over RRA-based NoCs
• Mallya and others, 2016, Using STPA in an ISO 26262 Compliant Process
• Ross, 2016, Why Functional Safety in Road Vehicles?
• Zhou and others, 2016, Worst case response time and schedulability analysis for real-time software transactional memory-lazy conflict detection STM-LCD
• Abdulkhaleq and Wagner, 2015, A controlled experiment for the empirical evaluation of safety analysis techniques for safety-critical software
• Sun and Lipari, 2015, A pre-order relation for exact schedulability test of sporadic tasks on multiprocessor Global Fixed-Priority scheduling
• Yelisetty and others, 2015, A set of metrics to assess and monitor compliance with RTCA DO-178C
• Baruah and others, 2015, A Strategy for Global Schedulability Analysis
• Yoon, 2015, A Study on Applying The DO-178C to The Control SW Development of The Military Aircraft Intercom Based on CMMI
• Lee and others, 2015, A Study on the Secure Software Development Life Cycle for Common Criteria CC Certification
• Khalilzad and others, 2015, Adaptive multi-resource end-to-end reservations for component-based distributed real-time systems
• Springer and others, 2015, Adaptive resource synchronization in hierarchical real-time systems
• Abdelaziz and others, 2015, Adaptive Software Development for developing safety critical software
• Li and others, 2015, An automated software reliability prediction system for safety critical software
• Nasri and Fohler, 2015, An Efficient Method for Assigning Harmonic Periods to Hard Real-Time Tasks with Period Ranges
• Burmyakov and others, 2015, An exact schedulability test for global FP using state space pruning
• Dordowsky, 2015, An experimental Study using ACSL and Frama-C to formulate and verify Low-Level Requirements from a DO-178C compliant Avionics Project
• Leu and others, 2015, An intelligent brake-by-wire system design and analysis in accordance with ISO-26262 functional safety standard
• Umamaheswrarao and others, 2015, An Optimal Weighted-Average Voting Algorithm for Software Safety Estimation on Safety-Critical Systems
• Ahmad and others, 2015, Analyzing different validation and verification techniques for safety critical software systems
• Utkin and others, 2015, Automated construction of software configuration tables for real-time systems in avionics
• Cherfi and others, 2015, Calculation of ISO 26262 Architectural Metrics from Fault Trees
• Thiele and Kumar, 2015, Can real-time systems be chaotic?
• Biscoglio and others, 2015, Certification and Legislation - An Italian Experience of Fiscal Software Certification
• Stürmer and others, 2015, Challenges in Managing ISO 26262 Software Development Projects
• Luppold and Falk, 2015, Code Optimization of Periodic Preemptive Hard Real-Time Multitasking Systems
• Lee and others, 2015, Composition of Schedulability Analyses for Real-Time Multiprocessor Systems
• Urriza and others, 2015, Computational Cost Reduction for Real-Time Schedulability Tests Algorithms
• Ito, 2015, Controllability in ISO 26262 and Driver Model
• Baruah and others, 2015, Density-Based Global Schedulability Tests
• Srivastava and others, 2015, Development of Electrical Power Assisted Steering EPAS Considering Safety and Reliability Aspects as per ISO 26262
• Guo and others, 2015, EDF Schedulability Analysis on Mixed-Criticality Systems with Permitted Failure Probability
• Sherer and others, 2015, Ensuring functional safety compliance for ISO 26262
• Ferreiros and Dias, 2015, Evaluation of Accomplishment of DO-178C Objectives by CMMI-DEV 1.3
• Gampa, 2015, Evaluation of Key Certification Aspects of Multi Core Platforms for Safety Critical Applications in Avionics Industry
• Gario and others, 2015, Fail-safe testing of safety-critical systems a case study and efficiency analysis
• Luo and others, 2015, Functional Safety Measurement in the Automotive Domain
• Wilhelm and others, 2015, Functional Safety of Driver Assistance Systems and ISO 26262
• Wilhelm and others, 2015, Funktionale Sicherheit und ISO 26262
• González Harbour and Buttazzo, 2015, Guest Editorial Special Issue on The Real-Time Systems Symposium
• Dziurzanski and others, 2015, Hard real-time guarantee of automotive applications during mode changes
• Papadopoulos and others, 2015, Hard real-time guarantees in feedback-based resource reservations
• Ebert, 2015, Implementing Functional Safety
• Xu and others, 2015, Improved Deadline Miss Models for Real-Time Systems Using Typical Worst-Case Analysis
• Niu and Xu, 2015, Improving schedulability and energy efficiency for window-constrained real-time systems with reliability requirement
• Knight and others, 2015, Integrating an assurance case into DO-178B compliant software development
• Wang and others, 2015, Integration of Cache Partitioning and Preemption Threshold Scheduling to Improve Schedulability of Hard Real-Time Systems
• Fan, 2015, Introduction to Embedded and Real-Time Systems
• Kawakoshi and others, 2015, ISO 26262 Controllability Evaluation Technique by Expert Riders
• Chen and others, 2015, k2U A General Framework from k-Point Effective Schedulability Analysis to Utilization-Based Tests
• Heininger and Hammerer, 2015, Leistungselektronik nach ISO 26262 prüfen
• de Matos Pedro and others, 2015, Logic-based schedulability analysis for compositional hard real-time embedded systems
• Uhrig and others, 2015, MESI-Based Cache Coherence for Hard Real-Time Multicore Systems
• Andrews and Fecarotti, 2015, Modelling life extension of safety critical systems
• Naija and others, 2015, New Schedulability Analysis for Real-Time Systems based on MDE and Petri Nets Model at Early Design Stages
• Mihalache and Bedoucha, 2015, Norme ISO 26262 application sur le logiciel du Boitier de Servitude Intelligent BSI de PSA
• Khalilzad and others, 2015, On Component-Based Software Development for Multiprocessor Real-Time Systems
• Davis and others, 2015, On the compatibility of exact schedulability tests for global fixed priority pre-emptive scheduling with Audsley’s optimal priority assignment algorithm
• Ingibergsson and others, 2015, On the Use of Safety Certification Practices in Autonomous Field Robot Software Development A Systematic Mapping Study
• Prosvirin and Kharchenko, 2015, OPTIMIZED SAFETY CRITICAL EMBEDDED AUTOMATIC FLIGHT CONTROL SYSTEM DEVELOPMENT APPROACH TO COMPLY WITH ARP 4754, DO-178C OBJECTIVES
• Souto and others, 2015, Overhead-Aware Schedulability Evaluation of Semi-Partitioned Real-Time Schedulers
• Mucha and others, 2015, Probabilistic worst case response time estimation for multi-core real-time systems
• Neto José Augusto and others, 2015, Product-based Safety Certification for Medical Devices Embedded Software
• Ward, 2015, Relaxing Resource-Sharing Constraints for Improved Hardware Management and Schedulability
• Arai and others, 2015, Research on Method for Classifying Injury Severity Using Motorcycle Accident Data for ISO 26262
• Abdeddaïm and others, 2015, Response time analysis for fixed priority real-time systems with energy-harvesting
• Valentin and others, 2015, Response time schedulability analysis for hard real-time systems accounting DVFS latency on heterogeneous cluster-based platform
• Lester, 2015, Risk-based alternatives to the DO-178C software design assurance process
• Salihovic and others, 2015, Road vehicles functional safety in accordance with series ISO 26262 standards
• Schoeberl, 2015, Scala for Real-Time Systems?
• Jiang and others, 2015, Schedulability Analysis for Real-Time P-FRP Tasks under Fixed Priority Scheduling
• Hua and others, 2015, Schedulability Analysis for Real-Time Task Set on Resource with Performance Degradation and Periodic Rejuvenation
• Ekberg and Yi, 2015, Schedulability analysis of a graph-based task model for mixed-criticality systems
• Chen and others, 2015, Schedulability analysis of non-preemptive strictly periodic tasks in multi-core real-time systems
• Saifullah and others, 2015, Schedulability Analysis under Graph Routing in WirelessHART Networks
• He and others, 2015, Schedulability of Fault Tolerant Real Time System Based on Local Optimum Checkpoint Under Priority Mixed Strategy
• 2015, Schedulers for BGW Tasks to Guarantee Quality of Service of Embedded Real-time Systems
• Youn and others, 2015, Software certification of safety-critical avionic systems DO-178C and its impacts
• Sarkar and others, 2015, Static Task Partitioning for Locked Caches in Multicore Real-Time Systems
• Beckers, 2015, Supporting ISO 26262 Hazard Analysis with Problem Frames
• Patil and S. P, 2015, Survey on Optimal Schedulability Test for Hard Real Time Scheduling
• Ruiz and others, 2015, Systematic Application of ISO 26262 on a SEooC - Support by Applying a Systematic Reuse Approach
• Huang and Chen, 2015, Techniques for Schedulability Analysis in Mode Change Systems under Fixed-Priority Scheduling
• Özçelik and Turgay Altilar, 2015, Test-Driven Approach for Safety-Critical Software Development
• Heininger and Hammerer, 2015, Testing Power Electronics According to ISO 26262
• Brauer and others, 2015, Tool-Supported Structural Coverage Analysis for DO-178C Compliant Software
• Duracz and others, 2015, Using Rigorous Simulation to Support ISO 26262 Hazard Analysis and Risk Assessment
• ljivo and others, 2015, Using Safety Contracts to Guide the Integration of Reusable Safety Elements within ISO 26262
• Niyizamwiyitira and others, 2015, Utilization-Based Schedulability Test of Real-Time Systems on Virtual Multiprocessors
• Gujarati and Brandenburg, 2015, When Is CAN the Weakest Link? A Bound on Failures-in-Time in CAN-Based Real-Time Systems