Performance optimization by dynamic code transformation

Homomorphic encryption facilitates secure computations on encrypted data without necessitating decryption, thereby ensuring robust protection of sensitive information. Nevertheless, these computations impose substantial performance overheads due to their inherent complexity. This research proposes an innovative approach that amalgamates GPU and FPGA acceleration, dynamic code generation, and parallelization to enhance the performance and scalability of homomorphic encryption algorithms.Our methodology employs GPU acceleration to harness the parallel processing capabilities of GPUs, FPGA acceleration to exploit custom, application-specific hardware configurations, dynamic code generation to produce optimized machine code, and automatic parallelization to distribute computations across multiple processing units. WE demonstrate the efficacy of our approach through extensive benchmarking against existing optimization strategies. Our findings reveal that this comprehensive optimization significantly reduces computational overhead and bolsters the performance of homomorphic encryption algorithms, particularly when processing large datasets. In summary, the proposed approach offers a practical solution for augmenting the performance of homomorphic encryption, rendering it suitable for real-world applications involving confidential data. Our contributions hold significant ramifications for the domains of cybersecurity and data privacy and provide fertile ground for future research endeavours.

This comparative study examines patterns of Large Language Model (LLM) weaponization through systematic analysis of four major exploitation incidents spanning from 2023-2025. While existing research focuses on isolated incidents or theoretical vulnerabilities, this study provides one of the first comprehensive comparative framework analyzing exploitation patterns across state-sponsored cyber-espionage (Anthropic Claude incident), academic security research (GPT-4 autonomous privilege escalation), social engineering platforms (SpearBot phishing framework), and underground criminal commoditization (WormGPT/FraudGPT ecosystem). Through comparative analysis across eight dimensions, adversary sophistication, target selection, exploitation techniques, autonomy levels, detection evasion, attribution challenges, defensive gaps, and capability democratization, this research identifies critical cross-case patterns informing defensive prioritization. Findings reveal three universal exploitation mechanisms transcending adversary types: autonomous goal decomposition via chain-of-thought reasoning (present in all four cases), dynamic tool invocation and code generation (3/4 cases), and adaptive social engineering (4/4 cases). Analysis demonstrates progressive capability democratization: state-level sophistication (Claude: 80-90% autonomy) transitioning to academic accessibility (GPT-4: 33-83% success rates), specialized criminal tooling (SpearBot: generative-critique architecture), and mass commoditization (WormGPT: $200-1700/year subscriptions). Comparative findings identify four cross-cutting defensive imperatives applicable regardless of adversary type: multi-turn conversational context monitoring, behavioral fingerprinting distinguishing legitimate from malicious complex workflows, federated threat intelligence enabling rapid cross-organizational learning, and capability-based access controls proportional to LLM reasoning sophistication.

White-box testing exercises a software system by ensuring that a model of the internal structure is covered by the test cases. Extending this approach to Web applications is far from obvious, because at least two abstraction levels can be considered to represent the internal structure of a Web application: the navigation model and the control flow model. To further complicate the matter, dynamic code generation must be taken into account in both models. In this paper, the two alternative models are presented and white-box testing criteria are defined on them. Their usage for the white-box testing of a real-world Web application is described, highlighting the associated costs and benefits.

Our earlier work reported a Threshold Scheduling Method for compile‐time mapping of functional parallism on distributed‐memory systems. The work reported in this paper discusses run‐time issues in efficiently supporting the functional parallism with minimal overheads, through a combination of compile‐time and run‐time ownership analysis.At compile time, the code generation phase determines whether a local copy of a live definition of a variable needed by a task is available on a given processor, through an ownership analysis. In case ownership cannot be resolved at compile time, an appropriate code is generated to perform analysis at run time. The code generation is carried out so that all the processors carry the same copy of the compiled program with the individual processor's code being isolated and the universally owned code being replicated on all processors to minimize run‐time overheads. The run‐time system maintains the static and dynamic ownerships at every processor to avoid communication overhead on ownership information.We demonstrate the approach by incorporating it in the compiler for targeting a parallel functional language, Sisal (streams and iterations in single assignment language), to Intel Touchstone i860 systems. Several benchmarks demonstrate the viability of the approach.

Recently, Jump-oriented Programming (JOP) attack has become widespread in various systems including server, desktop, and smart devices. JOP attack rearranges existing code snippets in program to make gadget sequences, and hijacks control flow of program by chaining and executing gadget sequences consecutively. However, existing defense schemes have limitations such as high execution overhead, high binary size increase overhead, and low applicability. In this paper, to solve these problems, we introduce target shepherding, which is a fast and space-efficient defender against general JOP attack. Our defense scheme generates monitoring code to determine whether the target is legitimate or not just before each indirect jump instruction at compile time, and then checks whether a control flow has been subverted by JOP attack at run time. We achieved very low run-time overhead with very small increase in file size. In our experimental results, the performance overhead is 2.36% and the file size overhead is 5.82% with secure execution.

The problem of complexity of developing and supporting the software cross-cutting concern and its solution using the aspect-oriented approach is examined. The complexity of aspect-oriented programming application in object-oriented programming languages is described. The problem of dependency of the declaration syntax of aspects and the method of their integration is investigated. The architecture that will provide the independence of the syntax of declaration and introduction of aspects in object-oriented programs is proposed. For separation, an urban design pattern that unites declaration of the aspect and its integration method is used. The system displays the classical entities of AOP in the object structure, which facilitates syntax mastering. Three methods for declaring aspects are developed, namely declaration using inheritance from a base class, template class generalization and flexible aspect creation at run time. For integration at compile time, a special integration module and the Roslyn compiler modification, which ensures implementation of the aspect configuration system and introduces advice invocation points in a code are developed. For integration at run time without using the dependency injection container, helper methods for creating proxy classes are designed. Also, modules for popular dependency injection containers, which allow integration by means of these containers are developed. Testing of the developed system, which showed a significant reduction in the size of a source code is carried out. The most pronounced reduction was in large enterprise-level systems. When using introduction at compile time, performance drop of programs is not observed. When using integration at run time, performance losses do not exceed those when using a similar proxy class.

This paper describes GBURG, which generates tiny, fast code generators based on finite-state machine pattern matching. The code generators translate postfix intermediate code into machine instructions in one pass (except, of course, for backpatching addresses). A stack-based virtual machine---known as the Lean Virtual Machine (LVM)---tuned for fast code generation is also described. GBURG translates the two-page LVM-to-x86 specification into a code generator that fits entirely in an 8 KB I-cache and that emits x86 code at 3.6 MB/set on a 266-MHz P6. Our just-in-time code generator translates and executes small benchmarks at speeds within a factor of two of executables derived from the conventional compile-time code generator on which it is based.

Compilers for current programming languages enforce rigid restrictions on changes, during the compilation of a statement, in the set of associations between names and declarations, that is, on changes in the compile-time environment of the statement. These restrictions inhibit the writing of well-structured, modular programs, because such programs tend to require frequent switching between the environments associated with different modules. With current compilers, arbitrary switching of environments must be handled by means of macros at compile time or deferred until run time. Conventional macros are difficult to use in situations where it is desirable that the macro writer and the macro user be ignorant about each other's programs. When deferred until run time, frequent switching of environments becomes costly owing to the overhead associated with subroutine calls. In order to encourage the compartmentalization of program information and at the same time to allow efficient code generation, we propose the relaxation of present restrictions on changes in the compile-time environment. Specifically, we propose that a group of declarations can be defined as an environment and that arbitrary pieces of program text can state within which environment they are to be compiled. With such a mechanism, program text can be intermixed by means of macros without having to make the relevant declarations global or having to repeat the declarations in places other than the environment's definition.

Numerous quantum algorithms require the use of quantum error correction to overcome the intrinsic unreliability of physical qubits. However, quantum error correction imposes a unique performance bottleneck, known as T -complexity, that can make an implementation of an algorithm as a quantum program run more slowly than on idealized hardware. In this work, we identify that programming abstractions for control flow, such as the quantum if-statement, can introduce polynomial increases in the T -complexity of a program. If not mitigated, this slowdown can diminish the computational advantage of a quantum algorithm. To enable reasoning about the costs of control flow, we present a cost model that a developer can use to accurately analyze the T -complexity of a program under quantum error correction and pinpoint the sources of slowdown. To enable the mitigation of these costs, we present a set of program-level optimizations that a developer can use to rewrite a program to reduce its T -complexity, predict the T -complexity of the optimized program using the cost model, and then compile it to an efficient circuit via a straightforward strategy. We implement the program-level optimizations in Spire, an extension of the Tower quantum compiler. Using a set of 11 benchmark programs that use control flow, we empirically show that the cost model is accurate, and that Spire's optimizations recover programs that are asymptotically efficient, meaning their runtime T -complexity under error correction is equal to their time complexity on idealized hardware. Our results show that optimizing a program before it is compiled to a circuit can yield better results than compiling the program to an inefficient circuit and then invoking a quantum circuit optimizer found in prior work. For our benchmarks, only 2 of 8 tested quantum circuit optimizers recover circuits with asymptotically efficient T -complexity. Compared to these 2 optimizers, Spire uses 54 × − 2400 × less compile time.

Managing communication is a difficult problem in distributed memory compilation. When the exact data to be communicated cannot be determined at compile time, communication optimizations can be performed by runtime routines which generate schedule for communication. This leads to two optimization problems: placing communication so that data once communicated can be reused if possible and placing schedule calls so that the result of runtime preprocessing can be reused for communicating as many times as possible. In large application codes, computation and communication is spread across multiple subroutines, so acceptable performance cannot be achieved without performing these optimizations across subroutine boundaries. In this paper, we present an Interprocedural Analysis Framework for these two optimization problems. Our optimizations are based on a program abstraction we call Control & Call Flow Graph. This extends the call graph abstraction by storing the control flow relations between various call sites within a subroutine. We show how communication placement and schedule call placement problems can be solved by data-flow analysis on Control & Call Flow Graph structure.

We present an approach for performing dynamic context-dependent transformations (DCDT) to improve code generation for programmable digital signal processors. Unlike static optimizations, DCDT can guarantee to improve the quality of the generated code, at the expense of longer computational time. For many embedded DSP applications, hand coding in assembly is still the only effective approach. We show that our code generation approach, when combined with DCDT, can yield code of quality comparable to that of hand-written codes by DSP experts and many times superior to that generated by a conventional optimizing compiler.

Signature-based control flow monitoring is a representative technique for detecting control flow errors in run time. However, it is very inefficient and time consuming to manually insert the monitoring code into a monitor-target application. In particular, for performance improvements of control-flow monitoring, implementing a monitoring code that operates in multi-thread makes things more complicated. In this paper, we propose an automatic code-generation framework that automatically translate an application into the control-flow monitorable application. In the proposed framework, the applied technique for control-flow monitoring is based on separate signature-based control-flow monitoring (SSCFM) technique that is able to expect performance improvements in multi-threaded or multi-core environments by separating the signature update and the signature verification on the thread level. The proposed framework automatically analyzes a monitor-target application and generates a SSCFM-applied application based on the analysis results. We anticipate that our automatic multi-thread code generation framework for control flow monitoring lessens the burden in runtime control-flow monitoring field.

The TaskGraph Library is a C++ library for dynamic code generation, which combines specialisation with dependence analysis and loop restructuring. A TaskGraph represents a fragment of code which is constructed and manipulated at runtime, then compiled, dynamically linked and executed. TaskGraphs are initialised using macros and overloading, which forms a simplified, C-like sub-language with first-class arrays and no pointers. Once a TaskGraph has been constructed, we can analyse its dependence structure and perform optimisations. In this Chapter, we present the design of the TaskGraph library, and two sample applications to demonstrate its use for runtime code specialisation and restructuring optimisation.

The traditional tradeoff when performing dynamic compilation is that of fast compilation time versus fast code performance. Most dynamic compilation systems for Java perform selective compilation and/or optimization at a method granularity. This is the not the optimal granularity level. However, compiling at a sub-method granularity is thought to be too complicated to be practical. This paper describes a straightforward technique for performing compilation and optimizations at a finer, sub-method granularity. We utilize dynamic profile data to determine intra-method code regions that are rarely or never executed, and compile and optimize the code without those regions. If a branch that was predicted to be rare is actually taken at run time, we fall back to the interpreter or dynamically compile another version of the code. By avoiding compiling and optimizing code that is rarely executed, we are able to decrease compile time significantly, with little to no degradation in performance. Futhermore, ignoring rarely-executed code can open up more optimization opportunities on the common paths. We present two optimizations---partial dead code elimination and rare-path-sensitive pointer and escape analysis---that take advantage of rare path information. Using these optimizations, our technique is able to improve performance beyond the compile time improvements

A class of high-performance, low-cost architectures that rely on the ability to predict, at compile time, the order in which shared resources (such as shared memories) will be accessed by the processors is discussed. If this ordering can be predicted at compile time and enforced at run time, then no hardware or software overhead is required for resolving contention for shared resources, and extremely efficient interprocessor communication is possible. Further, no overhead (such as semaphore management) is required for synchronization of the programs running on the component processors. The hardware required to enforce the ordered access of the shared resources is very simple. The result is a very lean multiprocessor architecture with very efficient access to shared resources. A specific example using Motorola DSP96002 processors and a shared memory is described in detail. >