Program Behavior Research Articles

Detecting Binary Incompatible Software Components Using Dynamic Loader

Modern programming languages support modular development dividing the system into separate translation units and compile them individually. A linker is used then to assemble together these units either statically or dynamically. This process, however, introduces implicit dependences between the translation units. When one or more units are modified in inconsistent way binary incompatibility occurs and may result in unexpected program behavior. Current mainstream programming languages neither specify what are the binary compatibility rules nor provide tools to check them.In this paper we discuss the details of various cases of binary incompatibility. We implemented a prototype solution in the Welltype programming language to detect binary compatibility by dynamic loader.

MIA: Metric Importance Analysis for Big Data Workload Characterization

Data analytics is at the foundation of both high-quality products and services in modern economies and societies. Big data workloads run on complex large-scale computing clusters, which implies significant challenges for deeply understanding and characterizing overall system performance. In general, performance is affected by many factors at multiple layers in the system stack, hence it is challenging to identify the key metrics when understanding big data workload performance. In this paper, we propose a novel workload characterization methodology using ensemble learning, called Metric Importance Analysis (MIA), to quantify the respective importance of workload metrics. By focusing on the most important metrics, MIA reduces the complexity of the analysis without losing information. Moreover, we develop the MIA-based Kiviat Plot (MKP) and Benchmark Similarity Matrix (BSM) which provide more insightful information than the traditional linkage clustering based dendrogram to visualize program behavior (dis)similarity. To demonstrate the applicability of MIA, we use it to characterize three big data benchmark suites: HiBench, CloudRank-D and SZTS. The results show that MIA is able to characterize complex big data workloads in a simple, intuitive manner, and reveal interesting insights. Moreover, through a case study, we demonstrate that tuning the configuration parameters related to the important metrics found by MIA results in higher performance improvements than through tuning the parameters related to the less important ones.

Program power profiling based on phase behaviors

Power profiling tools based on fast and accurate workload analysis can be useful for job scheduling and resource allocation aiming to optimize the power consumption of large-scale, high-performance computer systems. In this article, we propose a novel method for predicting the power consumption of a complete workload or application by extrapolating the power consumption of only a few code segments of the same application obtained from measurements. As such, it provides a fast and yet effective way for predicting the power consumption of the execution of both single and multi-threaded programs on arbitrary architectures without having to profile the entire program's execution. The latter would be costly to obtain, especially if it is a long-running program. Our method employs a set of code analysis tools to capture the program's phase behavior and then uses a multi-variable linear regression method to estimate the power consumption of the entire program. For validation, we select the SPEC 2006 benchmark suite and the NAS parallel benchmarks to evaluate the accuracy and effectiveness of our method. Experimental results on three generations of multicore processors show that our power profiling method achieves good accuracy in predicting program's energy use with relatively small errors.

Projected control graph for computing relevant program behaviors

Abstract Many software engineering tasks require analysis and verification of all behaviors relevant to the task. For example, all relevant behaviors must be analyzed to verify a safety or security property. An efficient algorithm must compute the relevant behaviors directly without computing all the behaviors. This is crucial in practice because it is computationally intractable if one were to compute all behaviors to find the subset of relevant behaviors. We present a mathematical foundation to define relevant behaviors and introduce the Projected Control Graph (PCG) as an abstraction to directly compute the relevant behaviors. We developed a PCG toolbox to facilitate the use of the PCG for program comprehension, analysis, and verification. The toolbox provides: (1) an interactive visual analysis mechanism, and (2) APIs to construct and use PCGs in automated analyses. The toolbox is designed to support multiple programming languages. Using the toolbox APIs, we conducted a verification case study of the Linux kernel to assess the practical benefits of using the PCG. The study shows that the PCG-based verification is faster and can verify 99% of 66,609 instances compared to the 66% instances verified by the formal verification tool used by the Linux Driver Verification (LDV) organization. This study has revealed bugs missed by the formal verification tool. The second case study is an interactive use of the PCG Smart View to detect side-channel vulnerabilities in Java bytecode.

STADS

A fundamental challenge of software testing is the statistically well-grounded extrapolation from program behaviors observed during testing. For instance, a security researcher who has run the fuzzer for a week has currently no means (1) to estimate the total number of feasible program branches, given that only a fraction has been covered so far; (2) to estimate the additional time required to cover 10% more branches (or to estimate the coverage achieved in one more day, respectively); or (3) to assess the residual risk that a vulnerability exists when no vulnerability has been discovered. Failing to discover a vulnerability does not mean that none exists—even if the fuzzer was run for a week (or a year). Hence, testing provides no formal correctness guarantees . In this article, I establish an unexpected connection with the otherwise unrelated scientific field of ecology and introduce a statistical framework that models Software Testing and Analysis as Discovery of Species (STADS). For instance, in order to study the species diversity of arthropods in a tropical rain forest, ecologists would first sample a large number of individuals from that forest, determine their species, and extrapolate from the properties observed in the sample to properties of the whole forest. The estimations (1) of the total number of species, (2) of the additional sampling effort required to discover 10% more species, or (3) of the probability to discover a new species are classical problems in ecology. The STADS framework draws from over three decades of research in ecological biostatistics to address the fundamental extrapolation challenge for automated test generation. Our preliminary empirical study demonstrates a good estimator performance even for a fuzzer with adaptive sampling bias—AFL, a state-of-the-art vulnerability detection tool. The STADS framework provides statistical correctness guarantees with quantifiable accuracy.

Risky behaviors of taxi drivers in Bandar Abbas, Iran.

Background and aimIt has been revealed that taxi drivers break more traffic rules than ordinary drivers. Such risky behaviors include stopping at prohibited areas and sudden change of direction. The present study aimed to determine the Risky Behaviors of Taxi Drivers in Bandar Abbas, IranMethodsIn this cross-sectional study, 184 taxi drivers were randomly selected from eight taxi stations located at different parts of Bandar Abbas city in 2016. Taxi drivers’ risky behaviors were evaluated via a 20-item questionnaire. Data were analyzed by SPSS version 19, using descriptive statistics and independent-samples t-test. The p-values less than 0.05 were considered as statistically significant.ResultsThe mean age of the drivers was 45.1 (±11.1) years. The mean of their occupational experience was 18.7 (±10.8) years. The risky behaviors which showed the highest frequency were respectively, failure to use signal-lights, driving too close to the cars in front, refusing to drive within the lanes and erratic lane changing.The lowest frequency belonged to running a red light, ignoring ‘no entry’ signs and taking illegal U-turns. Risky driving behaviors were shown to be significantly more prevalent among drivers with previous experience of crashes or tickets than drivers with no such experiences (p<0.01).ConclusionIncreasing the role of police supervision for the strict implementation of driving laws, and modification of the drivers’ behavior and implementation of periodic training programs on drivers’ safety issues can be considered for reducing taxi drivers’ unsafe behaviors.

Ripple: Reflection analysis for Android apps in incomplete information environments

SummaryReflection poses grave problems for static security analysis, despite its widespread use in Android apps. In general, string inference has been mainly used to handle reflection, resulting in significantly missed security vulnerabilities. In this work, we bring forward the ubiquity of incomplete information environments (IIEs) for Android apps, where some critical dataflows are missing during static analysis and the need for resolving reflective calls under IIEs. We present Ripple, the first IIE‐aware static reflection analysis for Android apps that resolves reflective calls more soundly than string inference. Validation with 17 popular Android apps from Google Play demonstrates the effectiveness of Ripple in discovering reflective targets with a low false positive rate (due to its trade‐off made among soundness, precision, and scalability). As a result, Ripple enables FlowDroid, a taint analysis for Android apps, to find hundreds of sensitive data leakages that would otherwise be missed. As a fundamental analysis, Ripple will be valuable for many security analysis clients, since more program behaviors can now be analyzed under IIEs.

Shape-Up and Eat Right Families Pilot Program: Feasibility of a Weight Management Shared Medical Appointment Model in African-Americans With Obesity at an Urban Academic Medical Center.

Disparities in obesity care exist among African-American children and adults. We sought to test the feasibility of a pilot program, a 1-year family-based intervention for African-American families with obesity [shape up and eat right (SUPER)], adopting the shared medical appointment model (SMA) at an urban safety net hospital. Primary outcomes: (1) family attendance rate and (2) program satisfaction. Secondary outcomes: change in body mass index (BMI), eating behaviors, and sedentary activity. Adult parents (BMI ≥ 25 kg/m2) ≥18 years and their child(ren) (BMI ≥ 85th percentile) ages 6-12 years from adult or pediatric weight management clinics were recruited. One group visit per month (n = 12) consisting of a nutrition and exercise component was led by a nurse practitioner and registered dietitian. Height and weight were recorded during each visit. Participants were queried on program satisfaction, food logs and exercise journals, Food Stamp Program's Food Behavior, and the Expanded Food and Nutrition Education Program food checklists. Thirteen participants from lower socioeconomic zip codes consented [n = 5 mothers mean age 33 years, BMI of 47.4 kg/m2 (31.4-73.6 kg/m2); n = 8 children; mean age 9 years, BMI of 97.6th percentile (94-99th percentile); 60% enrolled in state Medicaid]. Average individual attendance was 23.4% (14-43%; n = 13); monthly session attendance rates declined from 100 to 40% by program completion; two families completed the program in entirety. Program was rated (n = 5 adults) very satisfactory (40%) and extremely satisfactory (60%). Pre-intervention, families rated their eating habits as fair and reported consuming sugar-sweetened beverages or sports drinks, more so than watching more than 1 h of television (p < 0.002) or video game/computer activity (p < 0.006) and consuming carbonated sodas (p < 0.004). Post-intervention, reducing salt intake was the only statistically significant variable (p < 0.029), while children watched fewer hours of television and spent less time playing video games (from average 2 to 3 h daily; p < 0.03). Attendance was lower than expected though children seemed to decrease screen time and the program was rated satisfactory. Reported socioeconomic barriers precluded families from attending most sessions. Future reiterations of the intervention could be enhanced with community engagement strategies to increase participant retention.

A Denotational Semantics for SPARC TSO

The SPARC TSO weak memory model is defined axiomatically, with a non-compositional formulation that makes modular reasoning about programs difficult. Our denotational approach uses pomsets to provide a compositional semantics capturing exactly the behaviours permitted by SPARC TSO. Our approach facilitates the study of SPARC TSO and supports modular analysis of program behaviour.

The effect of sleep disturbances and internet addiction on suicidal ideation among adolescents in the presence of depressive symptoms

Maladaptive use of internet and sleep problems is a significant health concern among adolescents. We aimed to understand better how sleep problems are related to suicidal ideation taking into account the presence of depression and internet addiction. 631 adolescents aged between 12 and 18 randomly recruited from different middle and high schools to complete self-report questionnaires assessing sleep disturbances, addictive use of the internet, depressive symptoms, and suicidal ideation. 22.9% of the sample reported on suicidal ideation during the month before the study, 42% of the sample suffer from sleep disturbances, 30.2% reported on the addictive use of the internet, and 26.5% exhibited severe symptoms of depression. Adolescents with suicidal ideation had higher rates of sleep disturbances, addictive use of internet and depressive symptoms. A confirmatory path analysis suggests that the effect of sleep disturbances on suicidal ideation moderated by the impact of internet addiction and mediated by the sleep effects on depressive symptoms. These results emphasize the importance to address the above risk behaviors in prevention curriculums programs. Future longitudinal studies are needed to determine the temporal order and to validate causal pathways.

MMFilter : A CHR-Based Solver for Generation of Executions under Weak Memory Models

With the wide expansion of multiprocessor architectures, the analysis and reasoning for programs under weak memory models has become an important concern. This work presents MMFilter, an original constraint solver for generating program behaviors respecting a particular memory model. It is implemented in Prolog using CHR (Constraint Handling Rules). The CHR formalism provides a convenient generic solution for specifying memory models. It benefits from the existing optimized implementations of CHR and can be easily extended to new models. We present MMFilter design, illustrate the encoding of memory model constraints in CHR and discuss the benefits and limitations of the proposed technique.

A formal framework for software faults and permissions based on unified theory of programming

Safety and security are essential properties required by network and mobile applications. The former is concerned with detection of software faults and recovery from failures, and the latter is mainly about specifying and enforcing security policies. However, how to precisely understand and formally specify essential notations in safety and security disciplines, and how to integrate these properties with functional behaviour of programs, are still open issues. For this sake, in this paper, we propose a formal framework, trying to interpret safety and security notations on a common ontology, and combine security property with functional specification in a unified formalism. Our main contributions are two-folds: first, we formally define the notions of fault, failure and error in the traditional state-based model; and secondly, formally define permission mechanism in Android security system, and represent Hoare triples for security-related actions.

Pardis: a process calculus for parallel and distributed programming in Haskell

Parallel programming and distributed programming involve substantial amounts of boilerplate code for process management and data synchronisation. This leads to increased bug potential and often results in unintended non-deterministic program behaviour. Moreover, algorithmic details are mixed with technical details concerning parallelisation and distribution. Process calculi are formal models for parallel and distributed programming but often leave details open, causing a gap between formal model and implementation. We propose a fully deterministic process calculus for parallel and distributed programming and implement it as a domain-specific language in Haskell to address these problems. We eliminate boilerplate code by abstracting from the exact notion of parallelisation and encapsulating it in the implementation of our process combinators. Furthermore, we achieve correctness guarantees regarding process composition at compile time through Haskell’s type system. Our result can be used as a high-level tool to implement parallel and distributed programs.

Efficient parallel determinacy race detection for two-dimensional dags

A program is said to have a determinacy race if logically parallel parts of a program access the same memory location and one of the accesses is a write. These races are generally bugs in the program since they lead to non-deterministic program behavior --- different schedules of the program can lead to different results. Most prior work on detecting these races focuses on a subclass of programs with fork-join parallelism. This paper presents a race-detection algorithm, 2D-Order, for detecting races in a more general class of programs, namely programs whose dependence structure can be represented as planar dags embedded in 2D grids. Such dependence structures arise from programs that use pipelined parallelism or dynamic programming recurrences. Given a computation with T 1 work and T ∞ span, 2D-Order executes it while also detecting races in O ( T 1 / P + T ∞ ) time on P processors, which is asymptotically optimal. We also implemented PRacer, a race-detection algorithm based on 2D-Order for Cilk-P, which is a language for expressing pipeline parallelism. Empirical results demonstrate that PRacer incurs reasonable overhead and exhibits scalability similar to the baseline (executions without race detection) when running on multiple cores.

VS ensor

Performance variance becomes increasingly challenging on current large-scale HPC systems. Even using a fixed number of computing nodes, the execution time of several runs can vary significantly. Many parallel programs executing on supercomputers suffer from such variance. Performance variance not only causes unpredictable performance requirement violations, but also makes it unintuitive to understand the program behavior. Despite prior efforts, efficient on-line detection of performance variance remains an open problem. In this paper, we propose vS ensor , a novel approach for light-weight and on-line performance variance detection. The key insight is that, instead of solely relying on an external detector, the source code of a program itself could reveal the runtime performance characteristics. Specifically, many parallel programs contain code snippets that are executed repeatedly with an invariant quantity of work. Based on this observation, we use compiler techniques to automatically identify these fixed-workload snippets and use them as performance &lt;u&gt;v&lt;/u&gt;ariance &lt;u&gt;sensor&lt;/u&gt;s (v-sensors) that enable effective detection. We evaluate vS ensor with a variety of parallel programs on the Tianhe-2 system. Results show that vS ensor can effectively detect performance variance on HPC systems. The performance overhead is smaller than 4% with up to 16,384 processes. In particular, with vS ensor , we found a bad node with slow memory that slowed a program's performance by 21%. As a showcase, we also detected a severe network performance problem that caused a 3.37X slowdown for an HPC kernel program on the Tianhe-2 system.

Reference Abstract Domains and Applications to String Analysis

Abstract interpretation is a well established theory that supports reasoning about the run-time behaviour of programs. It achieves tractable reasoning by considering abstractions of run-time states, rather than the states themselves. The chosen set of abstractions is referred to as the abstract domain. We develop a novel framework for combining (a possibly large number of) abstract domains. It achieves the effect of the so-called reduced product without requiring a quadratic number of functions to translate information among abstract domains. A central notion is a reference domain, a medium for information exchange. Our approach suggests a novel and simpler way to manage the integration of large numbers of abstract domains. We instantiate our framework in the context of string analysis. Browser-embedded dynamic programming languages such as JavaScript and PHP encourage the use of strings as a universal data type for both code and data values. The ensuing vulnerabilities have made string analysis a focus of much recent research. String analysis tends to combine many elementary string abstract domains, each designed to capture a specific aspect of strings. For this instance the set of regular languages, while too expensive to use directly for analysis, provides an attractive reference domain, enabling the efficient simulation of reduced products of multiple string abstract domains.

تقويم البرامج التدريبية في عمادة خدمة المجتمع والتعليم المستمر بجامعة جازان في ضوء نموذج کيرک باتريک

تقويم البرامج التدريبية في عمادة خدمة المجتمع والتعليم المستمر بجامعة جازان في ضوء نموذج کيرک باتريک

Programming Requests/Responses with Greatfree in the Cloud Environment

Programming request with GreatFree is an efficient programming technique to implement distributed polling in the cloud computing environment. GreatFree is a distributed programming environment through which diverse distributed systems can be established through programming rather than configuring or scripting. GreatFree emphasizes the importance of programming since it offers developers the opportunities to leverage their distributed knowledge and programming skills. Additionally, programming is the unique way to construct creative, adaptive and flexible systems to accommodate various distributed computing environments. With the support of GreatFree code-level Distributed Infrastructure Patterns, Distributed Operation Patterns and APIs, the difficult procedure is accomplished in a programmable, rapid and highly-patterned manner, i.e., the programming behaviors are simplified as the repeatable operation of Copy-Paste-Replace. Since distributed polling is one of the fundamental techniques to construct distributed systems, GreatFree provides developers with relevant APIs and patterns to program requests/responses in the novel programming environment.

Imperative Programs Behavior Simulation in Terms of Compositional Petri Nets

Imperative Programs Behavior Simulation in Terms of Compositional Petri Nets

Consistency-Aware Scheduling for Weakly Consistent Programs

Modern geo-replicated data stores provide high availability by relaxing the underlying consistency requirements. Programs layered over such data stores are called weakly consistent programs. Due to the reduced consistency requirements, they exhibit highly nondeterministic behaviors, some of which might violate program invariants. Therefore, implementing correct weakly consistent programs and reasoning about them is challenging. In this paper, we present a systematic scheduling approach that is aware of the underlying consistency model. Our approach dynamically explores all possible program behaviors allowed by the used data store consistency model, and it evaluates program invariants during the exploration. We implement the approach in a prototype model checker for Antidote, which is a causally consistent key-value data store with convergent con ict handling. We evaluate our tool on several benchmarks. The results show that our approach is e effective in detecting buggy behaviors in weakly consistent programs.