To see the other types of publications on this topic, follow the link: Program of execution.
Journal articles on the topic 'Program of execution'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Program of execution.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
ZHAO, LEI, ZHENYU ZHANG, LINA WANG, and XIAODAN YIN. "A FAULT LOCALIZATION FRAMEWORK TO ALLEVIATE THE IMPACT OF EXECUTION SIMILARITY." International Journal of Software Engineering and Knowledge Engineering 23, no. 07 (2013): 963–98. http://dx.doi.org/10.1142/s0218194013500289.
Full textAbstract:
Coverage-based fault localization (CBFL) techniques contrast the execution spectra of a program entity to assess the extent of how much a program entity is being related to faults. However, different test cases may result in similar executions, which further make the execution spectra of program entities be indistinguishable among similar executions. As a consequence, most of the current CBFL techniques are impacted by the noise of indistinguishable spectra. To alleviate the impact of execution similarity and improve the effectiveness of CBFL techniques, we propose a general fault localization framework. This framework is general to current execution spectra based CBFL techniques, which could synthesize a fault localization technique based on a given base technique. To synthesize the new technique, we use the concept of coverage vector to model execution spectra and capture the execution similarity, then reduce the impact of execution similarity by counting distinct coverage vectors, and finally assess the suspiciousness of basic blocks being related to faults with the spectra of distinct coverage vectors. We adopt four representative fault localization techniques as base techniques, use seven Siemens programs and three median-sized real-life UNIX utility programs as subject programs, to conduct an experimental study on the effectiveness of our framework. The empirical evaluation shows that our framework can effectively alleviate the impact of execution similarity and generate more effective fault localization techniques based on existing ones.
2
Effinger, Robert, Brian Williams, Gerard Kelly, and Michael Sheehy. "Dynamic Controllability of Temporally-flexible Reactive Programs." Proceedings of the International Conference on Automated Planning and Scheduling 19 (October 16, 2009): 122–29. http://dx.doi.org/10.1609/icaps.v19i1.13372.
Full textAbstract:
In this paper we extend dynamic controllability of temporally-flexible plans to temporally-flexible reactive programs. We consider three reactive programming language constructs whose behavior depends on runtime observations; conditional execution, iteration, and exception handling. Temporally-flexible reactive programs are distinguished from temporally-flexible plans in that program execution is conditioned on the runtime state of the world. In addition, exceptions are thrown and caught at runtime in response to violated timing constraints, and handled exceptions are considered successful program executions. Dynamic controllability corresponds to a guarantee that a program will execute to completion, despite runtime constraint violations and uncertainty in runtime state. An algorithm is developed which frames the dynamic controllability problem as an AND/OR search tree over possible program executions. A key advantage of this approach is the ability to enumerate only a subset of possible program executions that guarantees dynamic controllability, framed as an AND/OR solution subtree.
3
Yadavally, Aashish, Yi Li, and Tien N. Nguyen. "Predictive Program Slicing via Execution Knowledge-Guided Dynamic Dependence Learning." Proceedings of the ACM on Software Engineering 1, FSE (2024): 271–92. http://dx.doi.org/10.1145/3643739.
Full textAbstract:
Program slicing, the process of extracting program statements that influence values at a designated location (known as the slicing criterion), is helpful in both manual and automated debugging. However, such slicing techniques prove ineffective in scenarios where executing specific inputs is prohibitively expensive, or even impossible, as with partial code. In this paper, we introduce ND-Slicer, a predictive slicing methodology that caters to specific executions based on a particular input, overcoming the need for actual execution. We enable such a process by leveraging execution-aware pre-training to learn the dynamic program dependencies, including both dynamic data and control dependencies between variables in the slicing criterion and the remaining program statements. Such knowledge forms the cornerstone for constructing a predictive backward slice. Our empirical evaluation revealed a high accuracy in predicting program slices, achieving an exact-match accuracy of 81.3% and a ROUGE-LCS F1-score of 95.4% on Python programs. As an extrinsic evaluation, we illustrate ND-Slicer’s usefulness in crash detection, with it locating faults with an accuracy of 63.9%. Furthermore, we include an in-depth qualitative evaluation, assessing ND-Slicer’s understanding of branched structures such as if-else blocks and loops, as well as the control flow in inter-procedural calls.
4
JAHIER, ERWAN, and MIREILLE DUCASSÉ. "Generic program monitoring by trace analysis." Theory and Practice of Logic Programming 2, no. 4-5 (2002): 611–43. http://dx.doi.org/10.1017/s1471068402001461.
Full textAbstract:
Program execution monitoring consists of checking whole executions for given properties, and collecting global run-time information. Monitoring gives valuable insights and helps programmers maintain their programs. However, application developers face the following dilemma: either they use existing monitoring tools which never exactly fit their needs, or they invest a lot of effort to implement relevant monitoring code. In this paper, we argue that when an event-oriented tracer exists, the compiler developers can enable the application developers to easily code their own monitors. We propose a high-level primitive called foldt which operates on execution traces. One of the key advantages of our approach is that it allows a clean separation of concerns; the definition of monitors is totally distinct from both the user source code and the language compiler. We give a number of applications of the use of foldt to define monitors for Mercury program executions: execution profiles, graphical abstract views, and two test coverage measurements. Each example is implemented by a few simple lines of Mercury.
5
Chen, Yuting. "Platform Independent Analysis of Probabilities on Multithreaded Programs." International Journal of Software Innovation 1, no. 3 (2013): 48–65. http://dx.doi.org/10.4018/ijsi.2013070104.
Full textAbstract:
A concurrent program is intuitively associated with probability: the executions of the program can produce nondeterministic execution program paths due to the interleavings of threads, whereas some paths can always be executed more frequently than the others. An exploration of the probabilities on the execution paths is expected to provide engineers or compilers with support in helping, either at coding phase or at compile time, to optimize some hottest paths. However, it is not easy to take a static analysis of the probabilities on a concurrent program in that the scheduling of threads of a concurrent program usually depends on the operating system and hardware (e.g., processor) on which the program is executed, which may be vary from machine to machine. In this paper the authors propose a platform independent approach, called ProbPP, to analyzing probabilities on the execution paths of the multithreaded programs. The main idea of ProbPP is to calculate the probabilities on the basis of two kinds of probabilities: Primitive Dependent Probabilities (PDPs) representing the control dependent probabilities among the program statements and Thread Execution Probabilities (TEPs) representing the probabilities of threads being scheduled to execute. The authors have also conducted two preliminary experiments to evaluate the effectiveness and performance of ProbPP, and the experimental results show that ProbPP can provide engineers with acceptable accuracy.
6
Zhang, Zhun, Xiang Wang, Qiang Hao, et al. "Hardware-Implemented Security Processing Unit for Program Execution Monitoring and Instruction Fault Self-Repairing on Embedded Systems." Applied Sciences 12, no. 7 (2022): 3584. http://dx.doi.org/10.3390/app12073584.
Full textAbstract:
Embedded systems are increasingly applied in numerous security-sensitive applications, such as industrial controls, railway transports, intelligent vehicles, avionics and aerospace. However, embedded systems are compromised in the execution of untrusted programs, where the instructions could be maliciously tampered with to cause unintended behaviors or program execution failures. Particularly for remote-controlled embedded systems, program execution monitoring and instruction fault self-repair are important to avoid unintended behaviors and execution interruptions. Therefore, this paper presents a hardware-enhanced embedded system with the integration of a Security Processing Unit (SPU) in which integrity signature checking and checkpoint-rollback mechanisms are coupled to achieve real-time program execution monitoring and instruction fault self-repairing. This System-on-Chip (SoC) design was implemented and validated on the Xilinx Virtex-5 FPGA development platform. Based on the evaluation of the SPU in terms of the performance overhead, security capability, and resource consumption, the experimental results show that, while the CPU executes different benchmarks, the average performance overhead of the SPU lowers to 1.92% at typical 8-KB I/D caches, and it provides both program monitoring and fault self-repairing capabilities. Unlike conventional hardware detection technologies that require manual handling to recovery program executions, the CPU–SPU collaborative SoC is a resilient architecture equipped with instruction tampering detection and a post-detection strategy of instruction fault self-repairing. Moreover, the embedded system satisfies a good balance between high security and resource consumption.
7
Thornton, John A., Heide A. Kinsinger, and Michael A. Luczak. "6.6.4 Case Study in Effective Government‐Contractor Partnering." INCOSE International Symposium 10, no. 1 (2000): 823–30. http://dx.doi.org/10.1002/j.2334-5837.2000.tb00460.x.
Full textAbstract:
AbstractAny Department of Defense (DoD) acquisition program manager would argue for more funding and more schedule as a rationale for successful program execution, claiming his or her program is on a “fast track”. At the same time, the days of having relief provided due to cost overruns and schedule delays are becoming history, and such perils unquestionably increase the risk of unwanted scrutiny of programs. These realities have challenged program managers to seek new and innovative ways to manage their programs. The government and contractor program managers for the Space and Naval Warfare System Command's Advanced Deployable System (ADS) Program have responded to this challenge by developing an effective government‐laboratory‐contractor partnership, and utilizing this efficient relationship in virtually every facet of program planning and execution. The case study presented in this paper discusses how the ADS Underwater Segment (UWS) has used this partnership in planning and executing its 42 month program, which was completed on time and under budget. It provides lessons learned from this management experience for consideration by other program managers interested on embarking on such a path.
8
Bergstra, Jan A., and Cornelis Middelburg. "Program Algebra for Turing-Machine Programs." Scientific Annals of Computer Science XXIX, no. 2 (2019): 113–39. https://doi.org/10.7561/SACS.2019.2.113.
Full textAbstract:
This paper presents an algebraic theory of instruction sequences with instructions for Turing tapes as basic instructions, the behaviours produced by the instruction sequences concerned under execution, and the interaction between such behaviours and Turing tapes provided by an execution environment. This theory provides a setting for the development of theory in areas such as computability and computational complexity that distinguishes itself by offering the possibility of equational reasoning and being more general than the setting provided by a known version of the Turing-machine model of computation. The theory is essentially an instantiation of a parameterized algebraic theory which is the basis of a line of research in which issues relating to a wide variety of subjects from computer science have been rigorously investigated thinking in terms of instruction sequences.
9
Griewank, Andreas, and Andrea Walther. "Optimal program execution reversal." ANZIAM Journal 42 (December 25, 2000): 627. http://dx.doi.org/10.21914/anziamj.v42i0.616.
Full text
10
Xin, Bin, William N. Sumner, and Xiangyu Zhang. "Efficient program execution indexing." ACM SIGPLAN Notices 43, no. 6 (2008): 238–48. http://dx.doi.org/10.1145/1379022.1375611.
Full text
11
WANG, CHENG, and YOUFENG WU. "FROM LOCKS TO CORRECT AND EFFICIENT TRANSACTIONAL MEMORY." Journal of Circuits, Systems and Computers 21, no. 02 (2012): 1240005. http://dx.doi.org/10.1142/s0218126612400051.
Full textAbstract:
Transactional memory addresses a number of important issues in lock-based parallel programs. Unfortunately, the semantics of transactions are different from those of critical sections defined by locks. The semantic differences make it difficult to correctly port existing lock-based programs to transaction-based programs. Experienced programmers accustomed to lock-based programming can easily make mistakes in transaction-based programming as parallel programs running correctly using locks can run incorrectly when critical sections are converted to using transactions. This problem becomes even more severe in porting lock-based programs to use the efficient software transactional memory. In this paper, we first identify three necessary properties in a program for the program execution using transactions to be equivalent to the program execution using locks. Assuming that the input lock-based program satisfies the necessary properties (i.e., a well-behaved parallel program), we next present a correctness condition to verify the transactional memory implementation in order for the program execution using transactions to be equivalent to the program execution using locks. Finally, we develop a correct and efficient software transactional memory implementation that satisfies the correctness condition so that locks in the well-behaved parallel programs can be converted to use the efficient software transactional memory easily and correctly.
12
Xun, Zhuyu, Hongfa Ding, and Zhou He. "Practical Time Optimization of DSP Program for High-frequency Applications." Journal of Physics: Conference Series 2095, no. 1 (2021): 012005. http://dx.doi.org/10.1088/1742-6596/2095/1/012005.
Full textAbstract:
Abstract The rapid development of the high frequency power conversion techniques makes great demands on the methods that can reduce the execution time of the program effectively. This paper is aiming at reducing the execution time of the program in several aspects such as sampling, complex expressions, and so on. As one of the most widely applied methods, reducing the execution time of the program at the cost of the memory space is adopted in this paper. Furthermore, in order to confirm the feasibility and superiority of programs that are proposed in this paper, they are compared with other programs that can realize the same function in terms of the execution time.
13
Metzler, Patrick, Neeraj Suri, and Georg Weissenbacher. "Extracting safe thread schedules from incomplete model checking results." International Journal on Software Tools for Technology Transfer 22, no. 5 (2020): 565–81. http://dx.doi.org/10.1007/s10009-020-00575-y.
Full textAbstract:
Abstract Model checkers frequently fail to completely verify a concurrent program, even if partial-order reduction is applied. The verification engineer is left in doubt whether the program is safe and the effort toward verifying the program is wasted. We present a technique that uses the results of such incomplete verification attempts to construct a (fair) scheduler that allows the safe execution of the partially verified concurrent program. This scheduler restricts the execution to schedules that have been proven safe (and prevents executions that were found to be erroneous). We evaluate the performance of our technique and show how it can be improved using partial-order reduction. While constraining the scheduler results in a considerable performance penalty in general, we show that in some cases our approach—somewhat surprisingly—even leads to faster executions.
14
Badau, Dana, Adela Badau, Virgil Ene-Voiculescu, et al. "The impact of technologies on the development of repetitive speed in handball, basketball and volleyball." Retos 64 (January 27, 2025): 809–24. https://doi.org/10.47197/retos.v64.111116.
Full textAbstract:
Introduction and objective: The study focused on identifying the differences regarding the implementation of a program that uses Fitlight technology and targets the development of simple and reactive repetitive speed in manual and bilateral manual executions. Methodology: There were 311 subjects in the study, including 243 student-athletes (handball, basketball, and volleyball) and 65 recreational subjects (control group). Study phasing: initial testing; implementing a 6-week experimental program using the Fitlight technology to improve manual, repetitive speed; final testing. Study tests: the Tapping the plates test-unilateral execution with the dominant hand (TP_dominant hand), the random reactive plate touching test_unilateral execution with the dominant hand (TPR_dominant hand), Touching the plates test- bilateral execution (TP_bilateral), Test Touching the plates bilateral execution-random reactive (TPR_bilateral). Results: The ANOVA analysis highlighted significant differences between the male and female groups, respectively, for all four versions of the Tapping Plate Test, for p<0.05. While analyzing the results of the male/female sports game groups, the most significant differences in progress were recorded in TP_dominant hand between Volleyball-Basketball with 0.179/0.126 executions; TPR_ dominant hand between Volleyball-Basketball -0.126/0.086 executions; TP_bilateral between Volleyball-Basketball -0.154/-0.173 executions; bilateral TPR_ between Volleyball-Handball -0.016/-0.033 executions. Analyzing the study results, we found that the control group recorded lower results than all the experimental groups. Conclusions: The Fitlight technology positively impacted the environment of simple and reactive repetitive speed as part of practicing an experimental program of specific exercises adapted to team sports games.
15
Bergan, Tom, Dan Grossman, and Luis Ceze. "Symbolic execution of multithreaded programs from arbitrary program contexts." ACM SIGPLAN Notices 49, no. 10 (2014): 491–506. http://dx.doi.org/10.1145/2714064.2660200.
Full text
16
Psarris, Kleanthis. "Program analysis techniques for transforming programs for parallel execution." Parallel Computing 28, no. 3 (2002): 455–69. http://dx.doi.org/10.1016/s0167-8191(01)00132-6.
Full text
17
Patrick, Metzler, Suri Neeraj, and Weissenbacher Georg. "Extracting Safe Thread Schedules from Incomplete Model Checking Results." International Journal on Software Tools for Technology Transfer, 2020 11636 (October 2, 2019): 153–71. https://doi.org/10.1007/978-3-030-30923-7_9.
Full textAbstract:
Model checkers frequently fail to completely verify a con- current program, even if partial-order reduction is applied. The verifica- tion engineer is left in doubt whether the program is safe and the effort towards verifying the program is wasted. We present a technique that uses the results of such incomplete ver- ification attempts to construct a (fair) scheduler that allows the safe execution of the partially verified concurrent program. This scheduler restricts the execution to schedules that have been proven safe (and prevents executions that were found to be erroneous). We evaluate the performance of our technique and show how it can be improved using partial-order reduction. While constraining the scheduler results in a considerable performance penalty in general, we show that in some cases our approach—somewhat surprisingly—even leads to faster executions.
18
Rashid, Muhammad, Syed Abdul Baqi Shah, Muhammad Arif, and Muhammad Kashif. "Determination of Worst-Case Data Using an Adaptive Surrogate Model for Real-Time System." Journal of Circuits, Systems and Computers 29, no. 01 (2019): 2050005. http://dx.doi.org/10.1142/s021812662050005x.
Full textAbstract:
The estimation of worst-case execution time (WCET) is a critical activity in the analysis of real-time systems. Evolutionary algorithms are frequently employed for the determination of worst-case data, used in the estimation of WCET. However, in order to employ an evolutionary algorithm, several executions of the application program are required, either on the target hardware or using its simulator. Multiple executions of the application program consume a huge amount of time. In order to reduce the huge execution time, this paper proposes the use of an adaptive surrogate model. The initial training of surrogate model is performed with a cycle-accurate simulator. The initially trained model is then used to assist the evolutionary algorithm by predicting the execution time of an application program. However, contrary to the direct training approach, the surrogate model in this paper is updated (adapted) during the evolution process. The adaptive training of a surrogate model increases its prediction accuracy and reduces the overall time. The validity of proposed methodology is illustrated with multiple sorting algorithms, extensively used in real-time systems.
19
Roth, Martin. "Program Execution in Connectionist Networks." Mind and Language 20, no. 4 (2005): 448–67. http://dx.doi.org/10.1111/j.0268-1064.2005.00295.x.
Full text
20
Linington, Janet, and Mark Dixon. "Picture program execution (poster session)." ACM SIGCSE Bulletin 33, no. 3 (2001): 175. http://dx.doi.org/10.1145/507758.377685.
Full text
21
Bergstra, Jan A., and Alban Ponse. "Execution architectures for program algebra." Journal of Applied Logic 5, no. 1 (2007): 170–92. http://dx.doi.org/10.1016/j.jal.2005.10.013.
Full text
22
Kishon, Amir, and Paul Hudak. "Semantics directed program execution monitoring." Journal of Functional Programming 5, no. 4 (1995): 501–47. http://dx.doi.org/10.1017/s0956796800001465.
Full textAbstract:
AbstractMonitoring semanticsis a formal model of program execution which captures ‘monitoring activity’ as found in profilers, tracers, debuggers, etc. Beyond its theoretical interest, this formalism provides a new methodology for implementing a large family of source-level monitoring activities for sequential deterministic programming languages. In this article we explore the use of monitoring semantics in the specification and implementation of a variety of monitors: profilers, tracers, collecting interpreters, and, most importantly, interactive source-level debuggers. Although we consider such monitors only for (both strict and non-strict) functional languages, the methodology extends easily to imperative languages, since it begins with a continuation semantics specification.In addition, using standard partial evaluation techniques as an optimization strategy, we show that the methodology forms a practical basis for building real monitors. Our system can be optimized at two levels of specialization: specializing the interpreter with respect to a monitor specification automatically yields an instrumented interpreter; further specializing this instrumented interpreter with respect to a source program yields an instrumented program, i.e. one in which the extra code to perform monitoring has been automatically embedded into the program.
23
THIEMANN, PETER. "Program specialization for execution monitoring." Journal of Functional Programming 13, no. 3 (2003): 573–600. http://dx.doi.org/10.1017/s0956796802004586.
Full text
24
Fischmeister, Sebastian, and Yanmeng Ba. "Sampling-based program execution monitoring." ACM SIGPLAN Notices 45, no. 4 (2010): 133–42. http://dx.doi.org/10.1145/1755951.1755908.
Full text
25
Chang, Bao Rong, Hsiu-Fen Tsai, and Po-Wen Su. "Applying Code Transform Model to Newly Generated Program for Improving Execution Performance." Scientific Programming 2021 (February 1, 2021): 1–21. http://dx.doi.org/10.1155/2021/6691010.
Full textAbstract:
The existing programs inside the voice assistant machine prompt human-machine interaction in response to a request from a user. However, the crucial problem is that the machine often may not give a proper answer to the user or cannot work out the existing program execution efficiently. Therefore, this study proposes a novel transform method to replace the existing programs (called sample programs in this paper) inside the machine with newly generated programs through code transform model GPT-2 that can reasonably solve the problem mentioned above. In essence, this paper introduces a theoretical estimation in statistics to infer at least a number of generated programs as required so as to guarantee that the best one can be found within them. In addition, the proposed approach not only imitates a voice assistant system with filtering redundant keywords or adding new keywords to complete keyword retrieval in semantic database but also checks code similarity and verifies the conformity of the executive outputs between sample programs and newly generated programs. According to code checking and program output verification, the processes can expedite transform operations efficiently by removing the redundant generated programs and finding the best-performing generated program. As a result, the newly generated programs outperform the sample programs because the proposed approach reduces the number of code lines by 32.71% and lowers the program execution time by 24.34%, which is of great significance.
26
Ji, Xiao Li, Xiao Song Zhang, Ting Chen, Xiao Shan Li, and Lei Jiang. "Loop Transparency for Scalable Dynamic Symbolic Execution." Applied Mechanics and Materials 201-202 (October 2012): 242–45. http://dx.doi.org/10.4028/www.scientific.net/amm.201-202.242.
Full textAbstract:
Dynamic symbolic execution is a promising approach for software analyzing and testing. However, it fails to scale to large programs due to the exponential number of paths to be explored. This paper focus on tackling loop caused path explosion problems and proposes a new approach to reduce paths that produce the same effects. We present a loop transparency strategy that makes use of the decision graph of under test program to discard constraints that produce paths with only a different number of iterations. A dynamic software testing tool LTDse based on loop transparency is designed and evaluated on three benchmarks. The experimental results show that our approach is effective since it can achieve better code coverage or require fewer program executions than traditional strategies.
27
Griuntal, A. I. "Functionally Independent Programs in Multitasking Environment." Programmnaya Ingeneria 15, no. 1 (2024): 3–11. http://dx.doi.org/10.17587/prin.15.3-11.
Full textAbstract:
his paper introduces a new concept of information security in respect to multitasking computational systems. According to the proposed definition a multitasking computational system is information secure, if execution of any application cannot negatively influence on other applications. Thus information security is being considered as protection of executing application and system programs from arbitrary actions of other application programs. Information security is provided by the software and hardware architecture, which guarantee information and functional independence of system and application programs and in time resource availability. A program is functionally independent if an execution sequence of program commands and a program itself could not be changed by other programs. This ensures integrity of programs. Compliance with there conditions is ensured by some technological and hardware means including static program and data allocation, separation of configuration and execution stages, special hardware features, minimizing the complexity of system programs. A computational system model is introduced for which functional independence requirements are fulfilled. Implementation of the model needs a new kind of hardware. Execution of some typical algorithms must be performed by hardware. Some computations performing as a rule by operating system are executed on configuration stage. The computational system consists of hardware, system programs and application programs. System programs nomenclature and their configuration do not depend on application programs. System programs and application programs do not depend on each other according to the data. A processor as a part of hardware can execute in addition to commands processor transactions, i.e. standard programs, determining computational process. Implementation of some programs as processor transactions allows to protect the computational system from uncontrolled interference by application programs. The model does not use any hardware means for memory protection. This is implemented using system programs. Planning is carried out by system programs. The scheduling algorithm guarantees the integrity of system and application programs. When scheduling, processing of application-specific data is carried out by processor transactions. This provides information security at the scheduling stage. The proposed hardware and software architecture can be used in information and computing systems for the maintenance of critical objects. Architecture can serve as a conceptual basis for creating systems for which information security requirements are primary, especially for those that function in real time.
28
Moiseenko, Evgenii, Michalis Kokologiannakis, and Viktor Vafeiadis. "Model checking for a multi-execution memory model." Proceedings of the ACM on Programming Languages 6, OOPSLA2 (2022): 758–85. http://dx.doi.org/10.1145/3563315.
Full textAbstract:
Multi-execution memory models, such as Promising and Weakestmo, are an advanced class of weak memory consistency models that justify certain outcomes of a concurrent program by considering multiple candidate executions collectively. While this key characteristic allows them to support effective compilation to hardware models and a wide range of compiler optimizations, it makes reasoning about them substantially more difficult. In particular, we observe that Promising and Weakestmo inhibit effective model checking because they allow some suprisingly weak behaviors that cannot be generated by examining one execution at a time. We therefore introduce Weakestmo2, a strengthening of Weakestmo by constraining its multi-execution nature, while preserving the important properties of Weakestmo: DRF theorems, compilation to hardware models, and correctness of local program transformations. Our strengthening rules out a class of surprisingly weak program behaviors, which we attempt to characterize with the help of two novel properties: load buffering race freedom and certification locality. In addition, we develop WMC, a model checker for Weakestmo2 with performance close to that of the best tools for per-execution models.
29
Zhang, Quan, Chijin Zhou, Yiwen Xu, et al. "Building Dynamic System Call Sandbox with Partial Order Analysis." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (2023): 1253–80. http://dx.doi.org/10.1145/3622842.
Full textAbstract:
Attack surface reduction is a security technique that secures the operating system by removing the unnecessary code or features of a program. By restricting the system calls that programs can use, the system call sandbox is able to reduce the exposed attack surface of the operating system and prevent attackers from damaging it through vulnerable programs. Ideally, programs should only retain access to system calls they require for normal execution. Many researchers focus on adopting static analysis to automatically restrict the system calls for each program. However, these methods do not adjust the restriction policy along with program execution. Thus, they need to permit all system calls required for program functionalities. We observe that some system calls, especially security-sensitive ones, are used a few times in certain stages of a program’s execution and then never used again. This motivates us to minimize the set of required system calls dynamically. In this paper, we propose , which gradually disables access to unnecessary system calls throughout the program’s execution. To accomplish this, we utilize partial order analysis to transform the program into a partially ordered graph, which enables efficient identification of the necessary system calls at any given point during program execution. Once a system call is no longer required by the program, can restrict it immediately. To evaluate , we applied it to seven widely-used programs with an average of 615 KLOC, including web servers and databases. With partial order analysis, restricts an average of 23.50, 16.86, and 15.89 more system calls than the state-of-the-art Chestnut, Temporal Specialization, and the configuration-aware sandbox, C2C, respectively. For mitigating malicious exploitations, on average, defeats 83.42% of 1726 exploitation payloads with only a 5.07% overhead.
30
GÓMEZ-ZAMALLOA, MIGUEL, ELVIRA ALBERT, and GERMÁN PUEBLA. "Test case generation for object-oriented imperative languages in CLP." Theory and Practice of Logic Programming 10, no. 4-6 (2010): 659–74. http://dx.doi.org/10.1017/s1471068410000347.
Full textAbstract:
AbstractTesting is a vital part of the software development process. Test Case Generation (TCG) is the process of automatically generating a collection of test-cases which are applied to a system under test. White-box TCG is usually performed by means of symbolic execution, i.e., instead of executing the program on normal values (e.g., numbers), the program is executed on symbolic values representing arbitrary values. When dealing with an object-oriented (OO) imperative language, symbolic execution becomes challenging as, among other things, it must be able to backtrack, complex heap-allocated data structures should be created during the TCG process and features like inheritance, virtual invocations and exceptions have to be taken into account. Due to its inherent symbolic execution mechanism, we pursue in this paper that Constraint Logic Programming (CLP) has a promising application field in tcg. We will support our claim by developing a fully CLP-based framework to TCG of an OO imperative language, and by assessing it on a corresponding implementation on a set of challenging Java programs.
31
Izadkhah, Habib. "Transforming Source Code to Mathematical Relations for Performance Evaluation." Annales Universitatis Mariae Curie-Sklodowska, sectio AI – Informatica 15, no. 2 (2015): 7. http://dx.doi.org/10.17951/ai.2015.15.2.7-13.
Full textAbstract:
Assessing software quality attributes (such as performance, reliability, and security) from source code is of the utmost importance. The performance of a software system can be improved by its parallel and distributed execution. The aim of the parallel and distributed execution is to speed up by providing the maximum possible concurrency in executing the distributed segments. It is a well known fact that distributing a program cannot be always caused speeding up the execution of it; in some cases, this distribution can have negative effects on the running time of the program. Therefore, before distributing a source code, it should be specified whether its distribution could cause maximum possible concurrency or not. The existing methods and tools cannot achieve this aim from the source code. In this paper, we propose a mathematical relationship for object oriented programs that statically analyze the program by verifying the type of synchronous and asynchronous calls inside the source code. Then, we model the invocations of the software methods by Discrete Time Markov Chains (DTMC). Using the properties of DTMC and the proposed mathematical relationship, we will determine whether or not the source code can be distributed on homogeneous processors. The experimental results showed that we can specify whether the program is distributable or not, before deploying it on the distributed systems.
32
Oz, Isil, Muhammad Khurram Bhatti, Konstantin Popov, and Mats Brorsson. "Regression-Based Prediction for Task-Based Program Performance." Journal of Circuits, Systems and Computers 28, no. 04 (2019): 1950060. http://dx.doi.org/10.1142/s0218126619500609.
Full textAbstract:
As multicore systems evolve by increasing the number of parallel execution units, parallel programming models have been released to exploit parallelism in the applications. Task-based programming model uses task abstractions to specify parallel tasks and schedules tasks onto processors at runtime. In order to increase the efficiency and get the highest performance, it is required to identify which runtime configuration is needed and how processor cores must be shared among tasks. Exploring design space for all possible scheduling and runtime options, especially for large input data, becomes infeasible and requires statistical modeling. Regression-based modeling determines the effects of multiple factors on a response variable, and makes predictions based on statistical analysis. In this work, we propose a regression-based modeling approach to predict the task-based program performance for different scheduling parameters with variable data size. We execute a set of task-based programs by varying the runtime parameters, and conduct a systematic measurement for influencing factors on execution time. Our approach uses executions with different configurations for a set of input data, and derives different regression models to predict execution time for larger input data. Our results show that regression models provide accurate predictions for validation inputs with mean error rate as low as 6.3%, and 14% on average among four task-based programs.
33
Bravetti, Mario. "RESTful Services and Web-OS Middleware: a Formal Specification Approach." JUCS - Journal of Universal Computer Science 23, no. (9) (2017): 808–44. https://doi.org/10.3217/jucs-023-09-0808.
Full textAbstract:
Web Operating Systems can be seen as an extension of traditional Operating Systems where the addresses used to manage files and execute programs (via the basic load/execution mechanism) are extended from local filesystem path-names to URLs. A first consequence is that, similarly as for traditional web technologies, executing a program at a given URL can be done in two modalities: either the execution is performed client-side at the invoking machine (and relative URL addressing in the executed program set to refer to the invoked URL) or it is performed server-side at the machine addressed by the invoked URL (as, e.g., for a web service). Moreover in this context, user identification for access to programs and files and workow-based composition of service programs is naturally based on token/session-like mechanisms. We propose a middleware based on client-server protocols and on a set primitives, for managing files/resources and executing programs (in the form of client-side/server-side components/services) in Web Operating Systems, based on an extension of the REST architecture. In order to provide an unambiguous specification, we formally define the semantics of such middleware by first introducing a process algebra for standard REST and then extending it to the whole middleware.
34
Li, Yi, Hridya Dhulipala, Aashish Yadavally, Xiaokai Rong, Shaohua Wang, and Tien N. Nguyen. "Blended Analysis for Predictive Execution." Proceedings of the ACM on Software Engineering 2, FSE (2025): 2987–3008. https://doi.org/10.1145/3729402.
Full textAbstract:
Although Large Language Models (LLMs) are highly proficient in understanding source code and descriptive texts, they have limitations in reasoning on dynamic program behaviors, such as execution trace and code coverage prediction, and runtime error prediction, which usually require actual program execution. To advance the ability of LLMs in predicting dynamic behaviors, we leverage the strengths of both approaches, Program Analysis (PA) and LLM, in building PredEx, a predictive executor for Python. Our principle is a blended analysis between PA and LLM to use PA to guide the LLM in predicting execution traces. We break down the task of predictive execution into smaller sub-tasks and leverage the deterministic nature when an execution order can be deterministically decided. When it is not certain, we use predictive backward slicing per variable, i.e., slicing the prior trace to only the parts that affect each variable separately breaks up the valuation prediction into significantly simpler problems. Our empirical evaluation on real-world datasets shows that PredEx achieves 31.5–47.1% relatively higher accuracy in predicting full execution traces than the state-of-the-art models. It also produces 8.6–53.7% more correct execution trace prefixes than those baselines. In predicting next executed statements, its relative improvement over the baselines is 15.7–102.3%. Finally, we show PredEx’s usefulness in two tasks: static code coverage analysis and static prediction of run-time errors for (in)complete code.
35
Erdei, Zsófia, Melinda Tóth, and István Bozó. "Supporting the debugging of Erlang programs by symbolic execution." Acta Universitatis Sapientiae, Informatica 16, no. 1 (2024): 44–61. https://doi.org/10.47745/ausi-2024-0004.
Full textAbstract:
Programmers can benefit from static source code analysis techniques in various ways: they can understand their code better, test it more effectively, debug it more efficiently, and so on. However, they often face the challenge of discovering how to reproduce faulty executions that cause runtime errors. The term symbolic execution refers to a static source code analysis method that can help with this challenge. In this paper, we are showing a symbolic execution-based analysis method to find the source of a runtime error. The method uses a control-flow graph to select the execution paths reaching the targeted runtime error. The algorithm is implemented as part of the RefactorErl static program analysis and transformation framework.
36
Tsai, Hui Chen, Kuo Chung Lin, and Ching Long Yeh. "Case Study of the Medical Decision-Making System ETL Abnormalities Processing Procedure." Advanced Materials Research 433-440 (January 2012): 894–99. http://dx.doi.org/10.4028/www.scientific.net/amr.433-440.894.
Full textAbstract:
The primary purpose of this research is to resolve the problem of ETL operation failure in execution of ETL (Extraction, Transformation and Loading) by the medical decision-making system due to data content, system factors and defective program design, thereby affect online daily operation of the application system and even customer complaint. This research first research and develop how to record in database, whether successful or not, the number of ETL file conversion program (including tool and self-wrote PL/SQL program) execution process, data status, and execution time; followed by designing control mechanism and write Script for voluminous table restoration for automatic execution by the system; afterwards followed by research and develop system automatic execution of restoration to stop only the affected application programs of the table and design a restoration mechanism. Lastly, through verification, this R&D result would correctly restore the data and table required by ETL procedure.
37
Laursen, Johan Sund, Lars-Peter Ellekilde, and Ulrik Pagh Schultz. "Modelling reversible execution of robotic assembly." Robotica 36, no. 5 (2018): 625–54. http://dx.doi.org/10.1017/s0263574717000613.
Full textAbstract:
SUMMARYProgramming robotic assembly for industrial small-batch production is challenging; hence, it is vital to increase robustness and reduce development effort in order to achieve flexible robotic automation. A human who has made an assembly error will often simply undo the process until the error is undone and then restart the assembly. Conceptually, robots could do the same. This paper introduces a programming model that enables robot assembly programs to be executed in reverse. We investigate the challenges in running robot programs backwards and present a classification of reversibility characteristics. We demonstrate how temporarily switching the direction of program execution can be an efficient error recovery mechanism. Moreover, we demonstrate additional benefits arising from supporting reversibility in an assembly language, such as increased code reuse and automatically derived disassembly sequences. As a default approach to reversibility, we use program inversion and statement-level inversion of commands, but with a novel override option providing alternative sequences for asymmetric reverse actions. To efficiently program for this model, this paper introduces a new domain-specific language, SCP-RASQ (Simple C++ Reversible Assembly SeQuences). In initial experiments, where 200 consecutive assemblies of two industrial cases were performed, 18 of 22 errors were corrected automatically using only the trial-and-error capabilities that come from reverse execution.
38
Nurwahyuni, Nurwahyuni, Al Rafni, Suryanef Suryanef, and Nurman S. "Pelaksanaan Program Peningkatan Literasi Politik Mahasiswa pada Unit Kegiatan-Wadah Pengkajian dan Pengembangan Sosial Politik Universitas Negeri Padang." Journal of Civic Education 7, no. 4 (2025): 229–35. https://doi.org/10.24036/jce.v7i4.962.
Full textAbstract:
This study examines the implementation of political literacy improvement programs by UK-WP2SOSPOL to enhance students' political knowledge. A qualitative descriptive method was used, with data collected through interviews and secondary sources such as websites, journals, and supporting documents. Informants included Student Affairs Expert Staff, Advisors, the Executive Board and UK-WP2SOSPOL members. The findings reveal two key stages in program implementation: planning and execution. Activities include social-political classes, public discussions, and bulletin publications. Supporting factors include organizational capabilities and the commitment of program implementers. However, challenges include weak organizational management, causing delays in execution, and limited dissemination of information beyond UK-WP2SOSPOL members, restricting broader student participation. This study highlights the need for improved organizational strategies and wider outreach efforts to ensure the program’s success. Strengthening management capabilities and expanding communication channels to engage a broader audience are recommended to maximize the impact of political literacy initiatives.
39
Gill, Satinder, Bryson J. Goolsby, and Dianne T. V. Pawluk. "Kinesthetic Feedback for Understanding Program Execution." Sensors 23, no. 11 (2023): 5159. http://dx.doi.org/10.3390/s23115159.
Full textAbstract:
To better prepare future generations, knowledge about computers and programming are one of the many skills that are part of almost all Science, Technology, Engineering, and Mathematic programs; however, teaching and learning programming is a complex task that is generally considered difficult by students and teachers alike. One approach to engage and inspire students from a variety of backgrounds is the use of educational robots. Unfortunately, previous research presents mixed results on the effectiveness of educational robots on student learning. One possibility for this lack of clarity may be because students have a wide variety of styles of learning. It is possible that the use of kinesthetic feedback, in addition to the normally used visual feedback, may improve learning with educational robots by providing a richer, multi-modal experience that may appeal to a larger number of students with different learning styles. It is also possible, however, that the addition of kinesthetic feedback, and how it may interfere with the visual feedback, may decrease a student’s ability to interpret the program commands being executed by a robot, which is critical for program debugging. In this work, we investigated whether human participants were able to accurately determine a sequence of program commands performed by a robot when both kinesthetic and visual feedback were being used together. Command recall and end point location determination were compared to the typically used visual-only method, as well as a narrative description. Results from 10 sighted participants indicated that individuals were able to accurately determine a sequence of movement commands and their magnitude when using combined kinesthetic + visual feedback. Participants’ recall accuracy of program commands was actually better with kinesthetic + visual feedback than just visual feedback. Although the recall accuracy was even better with the narrative description, this was primarily due to participants confusing an absolute rotation command with a relative rotation command with the kinesthetic + visual feedback. Participants’ zone location accuracy of the end point after a command was executed was significantly better for both the kinesthetic + visual feedback and narrative methods compared to the visual-only method. Together, these results suggest that the use of both kinesthetic + visual feedback improves an individual’s ability to interpret program commands, rather than decreases it.
40
Dias, Jéssica Costa, Afonso Welliton de Sousa Nascimento, and Alexandre Cals e Souza. "The CECAMPE Norte and its contributions to the consolidation and implementation of the Money Direct at the School Program (PDDE) in the municipality of Acará/PA: perspectives in analysis." Concilium 23, no. 6 (2023): 156–68. http://dx.doi.org/10.53660/clm-1091-23d25.
Full textAbstract:
This work presents a preliminary study about the Collaborating Center for Supporting the Monitoring and Management of Educational Programs – CECAMPE – North Region and its contribution to the consolidation and execution of the Direct Money at School Program (PDDE) in the municipality of Acará, the fundamental objective is to analyze and make available information regarding technical assistance and monitoring actions with regard to face-to-face training and visits to urban and rural/field schools that participated in the first stage of the CECAMPE Program in Acará. The research method used was qualitative through observation instruments, interviews and document analysis in order to perceive the contributions of technical assistance and monitoring of CECAMPE’s actions in the municipality of Acará. The initial results show that the PDDE is a fundamental program for basic education schools, because by making federal financial resources available, it allows the acquisition of goods and services that directly impact the development of pedagogical and administrative actions of the educational units and also strengthens the democratic management through the School Councils (Executing Units – Uex) which is responsible for the execution of the PDDE resources, carrying out the adhesion to the Program, the execution of the resource and the rendering of accounts with the instances of social and financial control. The study under development will significantly contribute to the understanding of this public policy that since 1995 has been providing conditions for improving the quality of education in basic education schools in the country.
41
LOULERGUE, F. "DISTRIBUTED EVALUATION OF FUNCTIONAL BSP PROGRAMS." Parallel Processing Letters 11, no. 04 (2001): 423–37. http://dx.doi.org/10.1142/s0129626401000701.
Full textAbstract:
The BS λp-calculus is a calculus of functional bulk synchronous parallel (BSP) programs. It is the basis for the design of a bulk synchronous parallel ML language. For data-parallel languages, there are two points of view: the programming model where a program is seen as a sequence of operations on parallel vectors, and the execution model where the program is a parallel composition of programs run on each processor of the parallel machine. BSP algorithms are defined by data-parallel algorithms with explicit (physical) processes in order to allow their parallel execution time to be estimated. We present here a distributed evaluation minimally synchronous for BSP execution (which corresponds to the execution model). This distributed evaluation is correct w.r.t. the call-by-value strategy of the BS λp-calculus (which corresponds to the programming model).
42
Prasad, Sanjiva. "Program Execution on Reconfigurable Multicore Architectures." Electronic Proceedings in Theoretical Computer Science 211 (June 17, 2016): 83–91. http://dx.doi.org/10.4204/eptcs.211.9.
Full text
43
Kozachok, A. V., and E. V. Kochetkov. "Verified program code execution system prototype." Proceedings of the Institute for System Programming of the RAS 29, no. 6 (2017): 7–24. http://dx.doi.org/10.15514/ispras-2017-29(6)-1.
Full text
44
Zhang, Xiangyu, and Rajiv Gupta. "Matching execution histories of program versions." ACM SIGSOFT Software Engineering Notes 30, no. 5 (2005): 197–206. http://dx.doi.org/10.1145/1095430.1081738.
Full text
45
Pan, Heidi, Krste Asanović, Robert Cohn, and Chi-Keung Luk. "Controlling program execution through binary instrumentation." ACM SIGARCH Computer Architecture News 33, no. 5 (2005): 45–50. http://dx.doi.org/10.1145/1127577.1127587.
Full text
46
Jayaraman, S., B. Jayaraman, and D. Lessa. "Compact visualization of Java program execution." Software: Practice and Experience 47, no. 2 (2016): 163–91. http://dx.doi.org/10.1002/spe.2411.
Full text
47
Borisov, Petr D., and Yu V. Kosolapov. "On the Automatic Analysis of the Practical Resistance of Obfusting Transformations." Modeling and Analysis of Information Systems 26, no. 3 (2019): 317–31. http://dx.doi.org/10.18255/1818-1015-2019-3-317-331.
Full textAbstract:
A method is developed for assessing the practical persistence of obfuscating transformations of programs based on the calculation of the similarity index for the original, obfuscated and deobfuscated programs. Candidates are proposed for similarity indices, which are based on such program characteristics as the control flow graph, symbolic execution time and degree of coverage for symbolic execution. The control flow graph is considered as the basis for building other candidates for program similarity indicators. On its basis, a new candidate is proposed for the similarity index, which, when calculated, finds the Hamming distance between the adjacency matrices of control flow graphs of compared programs. A scheme for estimating (analyzing) the persistence of obfuscating transformations is constructed, according to which for the original, obfuscated and deobfuscated programs, the characteristics of these programs are calculated and compared in accordance with the chosen comparison model. The developed scheme, in particular, is suitable for comparing programs based on similarity indices. This paper develops and implements one of the key units of the constructed scheme - a block for obtaining program characteristics compiled for the x86/x86 64 architecture. The developed unit allow to find the control flow graph, the time for symbolic execution and the degree of coverage for symbolic execution. Some results of work of the constructed block are given.
48
Gregorics, Tibor, and Zsolt Borsi. "A unified approach of program verification." Acta Universitatis Sapientiae, Informatica 9, no. 1 (2017): 65–82. http://dx.doi.org/10.1515/ausi-2017-0005.
Full textAbstract:
Abstract The subject of this paper is a program verification method that takes into account abortion caused by partial functions in program statements. In particular, boolean expressions of various statements will be investigated that are not well-defined. For example, a loop aborts if its execution begins in a state for which the loop condition is undefined. This work considers the program constructs of nondeterministic sequential programs and also deals with the synchronization statement of parallel programs introduced by Owicki and Gries [7]. The syntax of program constructs will be reviewed and their semantics will be formally defined in such a way that they suit the relational model of programming developed at Eőtvős Loránd University [3, 4]. This relational model defines the program as a set of its possible executions and also provides definition for other important programming notions like problem and solution. The proof rules of total correctness [2, 5, 8, 9, 7] will be extended by treating abortion caused by partial functions. The use of these rules will be demonstrated by means of a verification case study.
49
Renda, Alex, Yi Ding, and Michael Carbin. "Turaco: Complexity-Guided Data Sampling for Training Neural Surrogates of Programs." Proceedings of the ACM on Programming Languages 7, OOPSLA2 (2023): 1648–76. http://dx.doi.org/10.1145/3622856.
Full textAbstract:
Programmers and researchers are increasingly developing surrogates of programs, models of a subset of the observable behavior of a given program, to solve a variety of software development challenges. Programmers train surrogates from measurements of the behavior of a program on a dataset of input examples. A key challenge of surrogate construction is determining what training data to use to train a surrogate of a given program. We present a methodology for sampling datasets to train neural-network-based surrogates of programs. We first characterize the proportion of data to sample from each region of a program's input space (corresponding to different execution paths of the program) based on the complexity of learning a surrogate of the corresponding execution path. We next provide a program analysis to determine the complexity of different paths in a program. We evaluate these results on a range of real-world programs, demonstrating that complexity-guided sampling results in empirical improvements in accuracy.
50
GROIAN, Elena. "Implementation of the individual program for the execution of the criminal penalty." Revista Națională de Drept 10-12, no. 240-242 (2020): 159–65. https://doi.org/10.5281/zenodo.4303785.
Full textAbstract:
Implementation of the individual punishment execution program represents an essential motivation for the resocialization and reeducation of the convicted person. Analyzing the legislative-normative framework and the practices registered by the domestic penitenciary system and the experiences existing at European level, we can conclude that the penitenciary system and the Moldovian society have elaborated several initatives aimed at implementing an individual program of the execution of the sentence for the convicted persons and expressing an increased interest for the introduction a system based on the individualization of the execution of the sentence.