sequential programs
Recently Published Documents


TOTAL DOCUMENTS

161
(FIVE YEARS 24)

H-INDEX

15
(FIVE YEARS 1)

2022 ◽  
Vol 6 (POPL) ◽  
pp. 1-29
Author(s):  
Azalea Raad ◽  
Josh Berdine ◽  
Derek Dreyer ◽  
Peter W. O'Hearn

Incorrectness separation logic (ISL) was recently introduced as a theory of under-approximate reasoning, with the goal of proving that compositional bug catchers find actual bugs. However, ISL only considers sequential programs. Here, we develop concurrent incorrectness separation logic (CISL), which extends ISL to account for bug catching in concurrent programs. Inspired by the work on Views, we design CISL as a parametric framework, which can be instantiated for a number of bug catching scenarios, including race detection, deadlock detection, and memory safety error detection. For each instance, the CISL meta-theory ensures the soundness of incorrectness reasoning for free, thereby guaranteeing that the bugs detected are true positives.


2021 ◽  
Author(s):  
Edgar Sanchez Ramirez ◽  
Thi Phuong Lien Ung ◽  
Ximena del Toro Rios ◽  
Guadalupe R. Fajardo Orduna ◽  
Lilia G. Noriega ◽  
...  

Adipocytes are the main cell type in adipose tissue, a critical regulator of metabolism, highly specialized in storing energy as fat. Adipocytes differentiate from multipotent mesenchymal stromal cells through adipogenesis, a tightly controlled differentiation process involving closely interplay between metabolic transitions and sequential programs of gene expression. However, the specific gears driving this interplay remain largely obscure. Additionally, the metabolite nicotinamide adenine dinucleotide (NAD+) is becoming increasingly recognized as a regulator of lipid metabolism, being postulated as promising therapeutic target for dyslipidemia and obesity. Here, we explored the effect of manipulating NAD+ bioavailability during adipogenic differentiation from human mesenchymal stem cells. We found a previously unappreciated strong repressive role for NAD+ on adipocyte commitment, while a functional NAD+-dependent deacetylase SIRT1 appeared crucial for terminal differentiation of pre-adipocytes. Remarkably, repressing the NAD+ biosynthetic salvage pathway during adipogenesis promoted the adipogenic transcriptional program, suggesting that SIRT1 activity during adipogenesis is independent from the NAD+ salvage pathway, while two photon microscopy and extracellular flux analyses suggest that its activation relies on the metabolic switch. Interestingly, SIRT1-directed control of subcellular compartmentalization of redox metabolism during adipogenesis was evidenced by two-photon fluorescence lifetime microscopy.


2021 ◽  
Author(s):  
Henning Fernau ◽  
Lakshmanan Kuppusamy ◽  
Indhumathi Raman

AbstractA matrix insertion-deletion system (or matrix ins-del system) is described by a set of insertion-deletion rules presented in matrix form, which demands all rules of a matrix to be applied in the given order. These systems were introduced to model very simplistic fragments of sequential programs based on insertion and deletion as elementary operations as can be found in biocomputing. We are investigating such systems with limited resources as formalized in descriptional complexity. A traditional descriptional complexity measure of such a matrix ins-del system is its size $$s=(k;n,i',i'';m,j',j'')$$ s = ( k ; n , i ′ , i ′ ′ ; m , j ′ , j ′ ′ ) , where the parameters from left to right represent the maximal matrix length, maximal insertion string length, maximal length of left contexts in insertion rules, maximal length of right contexts in insertion rules; the last three are deletion counterparts of the previous three parameters. We call the sum $$n+i'+i''+m+j'+j''$$ n + i ′ + i ′ ′ + m + j ′ + j ′ ′ the sum-norm of s. We show that matrix ins-del systems of sum-norm 4 and sizes (3; 1, 0, 0;  1, 2, 0), (3; 1, 0, 0;  1, 0, 2), (2; 1, 2, 0;  1, 0, 0), (2; 1, 0, 2;  1, 0, 0), and (2; 1, 1, 1;  1, 0, 0) describe the recursively enumerable languages. Moreover, matrix ins-del systems of sizes (3; 1, 1, 0;  1, 0, 0), (3; 1, 0, 1;  1, 0, 0), (2; 2, 1, 0;  1, 0, 0) and (2; 2, 0, 1;  1, 0, 0) can describe at least the regular closure of the linear languages. In fact, we show that if a matrix ins-del system of size s can describe the class of linear languages $$\mathrm {LIN}$$ LIN , then without any additional resources, matrix ins-del systems of size s also describe the regular closure of $$\mathrm {LIN}$$ LIN . Finally, we prove that matrix ins-del systems of sizes (2; 1, 1, 0;  1, 1, 0) and (2; 1, 0, 1;  1, 0, 1) can describe at least the regular languages.


2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-29
Author(s):  
Chaitanya Koparkar ◽  
Mike Rainey ◽  
Michael Vollmer ◽  
Milind Kulkarni ◽  
Ryan R. Newton

Recent work showed that compiling functional programs to use dense, serialized memory representations for recursive algebraic datatypes can yield significant constant-factor speedups for sequential programs. But serializing data in a maximally dense format consequently serializes the processing of that data, yielding a tension between density and parallelism. This paper shows that a disciplined, practical compromise is possible. We present Parallel Gibbon, a compiler that obtains the benefits of dense data formats and parallelism. We formalize the semantics of the parallel location calculus underpinning this novel implementation strategy, and show that it is type-safe. Parallel Gibbon exceeds the parallel performance of existing compilers for purely functional programs that use recursive algebraic datatypes, including, notably, abstract-syntax-tree traversals as in compilers.


2021 ◽  
Vol 54 (5) ◽  
pp. 1-24
Author(s):  
Adilla Susungi ◽  
Claude Tadonki

While compilers generally support parallel programming languages and APIs, their internal program representations are mostly designed from the sequential programs standpoint (exceptions include source-to-source parallel compilers, for instance). This makes the integration of compilation techniques dedicated to parallel programs more challenging. In addition, parallelism has various levels and different targets, each of them with specific characteristics and constraints. With the advent of multi-core processors and general purpose accelerators, parallel computing is now a common and pervasive consideration. Thus, software support to parallel programming activities is essential to make this technical transition more realistic and beneficial. The case of compilers is fundamental as they deal with (parallel) programs at a structural level, thus the need for intermediate representations. This article surveys and discusses attempts to provide intermediate representations for the proper support of explicitly parallel programs. We highlight the gap between available contributions and their concrete implementation in compilers and then exhibit possible future research directions.


Author(s):  
Rashmi Mudduluru ◽  
Jason Waataja ◽  
Suzanne Milstein ◽  
Michael D. Ernst
Keyword(s):  

2021 ◽  
Vol 16 (92) ◽  
pp. 60-71
Author(s):  
Alexander S. Fedulov ◽  
◽  
Yaroslav A. Fedulov ◽  
Anastasiya S. Fedulova ◽  
◽  
...  

This work is devoted to the problem of implementing an efficient parallel program that solves the asigned task using the maximum available amount of computing cluster resources in order to obtain the corresponding gain in performance with respect to the sequential version of the algorithm. The main objective of the work was to study the possibilities of joint use of the parallelization technologies OpenMP and MPI, considering the characteristics and features of the problems being solved, to increase the performance of executing parallel algorithms and programs on a computing cluster. This article provides a brief overview of approaches to calculating the sequential programs complexity functions. To determine the parallel programs complexity, an approach based on operational analysis was used. The features of the sequential programs parallelization technologies OpenMP and MPI are described. The main software and hardware factors affecting the execution speed of parallel programs on the nodes of a computing cluster are presented. The main attention in this paper is paid to the study of the impact on performance of computational and exchange operations number ratio in programs. To implement the research, parallel OpenMP and MPI testing programs were developed, in which the total number of operations and the correlation between computational and exchange operations are set. A computing cluster consisting of several nodes was used as a hardware and software platform. Experimental studies have made it possible to confirm the effectiveness of the hybrid model of a parallel program in multi-node systems with heterogeneous memory using OpenMP in shared memory subsystems, and MPI in a distributed memory subsystems


Sign in / Sign up

Export Citation Format

Share Document