A comparison of concurrent programming and cooperative multithreading

This paper presents a comparison of the cooperative multithreading model with the general concurrent programming model. It focuses on the execution time performance of a range of standard concurrent programming applications. The overall results are mixed. In some cases, programs written in the cooperative multithreading model outperform those written in the general concurrent programming model. The contributions of this paper are twofold. First, it presents a thorough analysis of the performances of applications in the different models, i.e. to explain the criteria that determine when a program in one model will outperform an equivalent program in the other. Second, it examines the tradeoffs in writing programs in the different programming styles. In some cases, better performance comes at the cost of more complicated code. Copyright © 2003 John Wiley & Sons, Ltd.     

Four styles of parallel and net programming

This paper reviews the programming landscape for parallel and network computing systems, focusing on four styles of concurrent programming models, and example languages/libraries. The four styles correspond to four scales of the targeted systems. At the smallest coprocessor scale, Single Instruction Multiple Thread (SIMT) and Compute Unified Device Architecture (CUDA) are considered. Transactional memory is discussed at the multicore or process scale. The MapReduce style is examined at the datacenter scale. At the Internet scale, Grid Service Markup Language (GSML) is reviewed, which intends to integrate resources distributed across multiple datacenters. The four styles are concerned with and emphasize different issues, which are needed by systems at different scales. This paper discusses issues related to efficiency, ease of use, and expressiveness.     

Programming Styles in Nial

The programming language Nial several styles f supports several styles of programming including imperative, procedural, applicative, and lambda-free. Nial tools can be built to illustrate relational and object-oriented styles of programming.     

Interactive design of 3D models with geometric constraints

In this paper, an interactive graphical approach for the design of parameterized part-hierarchies is presented. Primitive solids can be grouped into compound objects, and multiple instances of a compound object can be used in further designs. Geometric relations between primitives and instances are specified by geometric constraints between their local coordinate systems. The user can specify and edit a model by direct manipulation on a perspective or parallel projection with a mouse, whereas a procedural model representations is automatically generated via visual programming. The obtained twoview approach offers two concurrent interface styles to the end-user and enables the combination of an intuitive direct manipulation interface with the expressiveness of a procedural modeling language.     

Views of queues

Starting from an algebraic specification of the data type QUEUE several variants of communicating agents representing queues are studied. It is demonstrated how new issues such as exceptions, robustness, and concurrency can be considered, when going from a purely algebraic view of queues to queues used in the framework of communicating systems. Nevertheless the verification of the communicating agents can be done by classical techniques for proving implementations correct, developed in the framework of algebraic specification. Finally the design of infinite networks representing queues and their verification is demonstrated. Although shown only for a simple example a general method is aimed at for the development of interactive and concurrent programs from algebraic specification using applicative programming styles.     

论面向对象与逻辑系统的结合

本文着重讨论了面向对象的基本思想和逻辑程序设计思想的关系,比较了各自的优缺点和相互补充的可能,从新的角度论述了将面向对象程序设计与逻辑程序设计相结合的一种可行途径,最后,提出了一系列具体的实现方法。     

The problem with threads

For concurrent programming to become mainstream, we must discard threads as a programming model. Nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs. In general-purpose software engineering practice, we have reached a point where one approach to concurrent programming dominates all others namely, threads, sequential processes that share memory. They represent a key concurrency model supported by modern computers, programming languages, and operating systems. In scientific computing, where performance requirements have long demanded concurrent programming, data-parallel language extensions and message-passing libraries such as PVM, MPI, and OpenMP dominate over threads for concurrent programming. Computer architectures intended for scientific computing often differ significantly from so-called general-purpose architectures.     

Concurrent programming in VISO

Concurrent programming is more difficult to use and understand than sequential programming. In order to simplify this type of programming a number of approaches have been developed such as visual programming. Visual Occam (VISO) is a visual programming language for concurrent programming. It has a graphical syntax based on the language Occam and its semantics is represented both in petri net and process calculus. This paper presents a modular visual approach to write concurrent programs using the VISO language. Concurrent programs in VISO are specified graphically at different levels of abstraction. This paper describes this modular visual approach by constructing two examples in VISO. The first example is a simple concurrent program and it is mainly used to show the details of constructing a concurrent program in VISO. The second example is a larger concurrent program with more levels of abstraction. Copyright © 2000 John Wiley & Sons, Ltd.     

并发面向对象程序设计语言研究与进展

随着面向对象程序设计的普及和对并发应用程序需求的增加，并发面向对象程序设计语言的设计日益成为研究热点。     

An implementation of the object-oriented concurrent programming language SINA

SINA is an object-oriented language for distributed and concurrent programming. The primary focus of this paper is on the object-oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter-object communication, some illustrative examples and a message-based implementation model for SINA that we have used in our current implementation.     

Processes, Tasks, and Monitors: A Comparative Study of Concurrent Programming Primitives

Three notations for concurrent programming are compared, namely CSP, Ada, and monitors. CSP is an experimental language for exploring structuring concepts in concurrent programming. Ada is a general-purpose language with concurrent programming facilities. Monitors are a construct for managing access by concurrent processes to shared resources. We start by comparing "lower-level" communication, synchronization, and nondeterminism in CSP and Ada and then examine "higher-level" module interface properties of Ada tasks and monitors.     

Rendezvous facilities: Concurrent C and the Ada language

The concurrent programming facilities in both Concurrent C and the Ada language are based on the rendezvous concept. Although these facilities are similar, there are substantial differences. Facilities in Concurrent C were designed keeping in perspective the concurrent programming facilities in the Ada language and their limitations. Concurrent C facilities have also been modified as a result of experience with its initial implementations. The authors compare the concurrent programming facilities in Concurrent C and Ada and show that it is easier to write a variety of concurrent programs in Concurrent C than in Ada     

一种支持虚拟共享存储空间的并行程序设计模型

本文研究机群系统的程序设计问题，旨在建立一种支持虚拟共享存储空间和多种并行性描述方式的并行程序设计模型。文中首先提出了抽象结构共享存储器模型的概念，并在此基础上建立了同时支持数据并行、任务并行和对象并行的层次并行模型，这两种模型构成了并行语言ＴｉｐＣ＋＋的并行程序设计模型。文中还初步讨论了基于这种程序设计模型的性能优化原语、编译优化和任务调度等问题。     

并发行为对象的构造

本文提出了一种新的刻划并发行为的方法.这种方法的基础是笔者近年来设计并实现的一种面向对象的程序设计语言.尽管语言本身没有特别引入用于并发程序设计的设施,但它却能用来描述各种并发行为的模型,并以完善的高级形式提交给用户.     

C++教学中编程习惯的养成

面向对象程序设计课程在整个计算机理论和实践教学体系中占据非常重要的地位。很多学生在学完C++课程后,能够初步掌握基本语法和面向对象设计思想,但是编出来的程序质量非常低,程序可读性、稳定性和可重用性非常差,离实际软件开发的要求相差甚远,其中部分原因就是没有好的编程习惯。本文着重就好的C++编程习惯要求和养成做一些探讨,希望通过平时课堂教学和课外实验,学生可以掌握一般的编程风格,养成良好的编程习惯。     

Programmers: concrete women and abstract men?

Abstract Sherry Turkle and Seymour Papert have identified a hands-on and experimental 'concrete' approach to computer programming as feminine, and as a fully formed way of knowing how to program, rather than as either a learning style or as a stage in development. This paper differentiates between concrete styles of learning how to program, and the concrete style of programming. Learning strategy is decoupled from programming style, and the hypothesis that women are more likely than men to prefer a concrete style of programming is tested by means of examining responses to practical examples of concrete and abstract styles. The responses suggest that there is no significant difference between women and men in their attitude toward a concrete style of programming.     

一个并发对象演算

由于缺乏一个为人们接受的描述并发对象系统语义的形式化模型,开发面向对象程序设计语言的开发受到了很大的制约,为了给并发面向对象程序设计定义一个公共的语义框架,人们分别以π演算和ａｃｔｏｒ模型为基础进行了研究。     

Apla语言中并发分布式机制的研究

从并发分布式程序设计的角度,对现有的并发分布式语言进行分析比较,选取Jayadev Misra教授近几年提出的全新结构化并发分布式语言Orc作为研究对象。通过深入分析Orc语言的基本原理和语言特征,提出了一个能够适合Apla抽象程序设计语言的并发分布式机制,设计了并发算子、并发语句、进程定义、进程通信和进程同步,并通过实例探讨了该设计方案的可行性和实用性,最后阐述了Apla语言中并发分布式机制具有通用性强、抽象层次高、简单易懂、便于并发分布式程序的开发等优点。     

A Simple, Object-Based View of Multiprogramming

Object-based sequential programming has had a major impact on software engineering. However, object-based concurrent programming remains elusive as an effective programming tool. The class of applications that will be implemented on future high-bandwidth networks of processors will be significantly more ambitious than the current applications (which are mostly involved with transmissions of digital data and images), and object-based concurrent programming has the potential to simplify designs of such applications. Many of the programming concepts developed for databases, object-oriented programming and designs of reactive systems can be unified into a compact model of concurrent programs that can serve as the foundation for designing these future applications. We propose a model of multiprograms and a discipline of programming that addresses the issues of reasoning (e.g., understanding) and efficient implementation. The major point of departure is the disentanglement of sequential and multiprogramming features. We propose a sparse model of multiprograms that distinguishes these two forms of computations and allows their disciplined interactions.     

Using atomic await commands to develop concurrent programs in Java

Systematic techniques for dealing with concurrency can be very helpful in concurrent programming. In his concurrent programming text, Andrews [2] describes a technique for developing concurrent programs based on first developing solutions using course-grained atomic commands and atomic await primitives (which are usually not available in real programming environments), then systematically transforming the solution to an implementation that uses available synchronization primitives. Transformations are known for semaphores, conditional critical regions, and monitors. In this paper, transformations are given for the synchronization constructs provided by the Java programming language [1]. Familiarity with the basic facilities to support concurrency provided by Java is assumed.