Programming language support for adaptable wearable computing

Author(s):  
P.K. McKinley ◽  
S.M. Sadjadi ◽  
E.P. Kasten ◽  
R. Kalaskar
1986 ◽  
pp. 282-311
Author(s):  
R. T. Hood ◽  
K. Kennedy

2009 ◽  
Vol 35 (3) ◽  
pp. 306-321 ◽  
Author(s):  
Bard Bloom ◽  
Paul Keyser ◽  
Ian Simmonds ◽  
Mark Wegman

Author(s):  
Yung-Hsiang Lu ◽  
Milind Kulkarni ◽  
Nouraldin Jaber ◽  
Jerry Xiaojin Zhu

2021 ◽  
Vol 40 (2) ◽  
pp. 51-54
Author(s):  
Kyle Chard ◽  
James Muns ◽  
Richard Wai ◽  
S. Tucker Taft

Language constructs that support parallel computing are relatively well recognized at this point, with features such as parallel loops (optionally with reduction operators), divide-and-conquer parallelism, and general parallel blocks. But what language features would make distributed computing safer and more productive? Is it helpful to be able to specify on what node a computation should take place, and on what node data should reside, or is that overspecification? We don't normally expect a user of a parallel programming language to specify what core is used for a given iteration of a loop, nor which data should be moved into which core's cache. Generally the compiler and the run-time manage the allocation of cores, and the hardware worries about the cache. But in a distributed world, communication costs can easily outweigh computation costs in a poorly designed application. This panel will discuss various language features, some of which already exist to support parallel computing, and how they could be enhanced or generalized to support distributed computing safely and efficiently.


2021 ◽  
Vol 33 (5) ◽  
pp. 137-154
Author(s):  
Leonid Vladlenovich Skvortsov ◽  
Roman Vyacheslavovich Baev ◽  
Ksenia Yurievna Dolgorukova ◽  
Eugene Yurievich Sharygin

Development for stack-based architectures is usually done using legacy low level languages or assembly code, so there exists a problem of a high level programming language support for such architectures. In this paper we describe the development process of an LLVM/Clang-based C compiler for stack-based TF16 processor architecture. LLVM was used due to adaptation possibilities of its components for new architectures, such as disassembler, linker and debugger. Two compiler versions were developed. The first version generated code without using stack capabilities of TF16, treating it instead as a register-based architecture. This version was relatively easy to develop and it provided us a comparison point for the second one. In the second version we have implemented a platform independent stack scheduling algorithm that allowed us to generate code that makes use of the stack capabilities of the CPU. When comparing the two versions, a version that utilized stack capabilities generated code that was on average 35.7% faster and 50.8% smaller than the original version. The developed stack scheduling algorithm also allows to support other stack based architectures in LLVM toolchain.


Sign in / Sign up

Export Citation Format

Share Document