精华内容
下载资源
问答
  • 并行程序设计导论(英文版)》CHAPTER 1 Why Parallel Computing? 11.1 Why We Need Ever-Increasing Performance 21.2 Why We’re Building Parallel Systems 31.3 Why We Need to Write Parallel Programs 31.4 ...

    《并行程序设计导论(英文版)》

    CHAPTER 1 Why Parallel Computing? 1

    1.1 Why We Need Ever-Increasing Performance 2

    1.2 Why We’re Building Parallel Systems 3

    1.3 Why We Need to Write Parallel Programs 3

    1.4 How Do We Write Parallel Programs? 6

    1.5 What We’ll Be Doing 8

    1.6 Concurrent, Parallel, Distributed 9

    1.7 The Rest of the Book 10

    1.8 A Word of Warning 10

    1.9 Typographical Conventions 11

    1.10 Summary 12

    1.11 Exercises 12

    CHAPTER 2 Parallel Hardware and Parallel Software 15

    《并行程序设计导论(英文版)》

    CHAPTER 1 Why Parallel Computing? 1

    1.1 Why We Need Ever-Increasing Performance 2

    1.2 Why We’re Building Parallel Systems 3

    1.3 Why We Need to Write Parallel Programs 3

    1.4 How Do We Write Parallel Programs? 6

    1.5 What We’ll Be Doing 8

    1.6 Concurrent, Parallel, Distributed 9

    1.7 The Rest of the Book 10

    1.8 A Word of Warning 10

    1.9 Typographical Conventions 11

    1.10 Summary 12

    1.11 Exercises 12

    CHAPTER 2 Parallel Hardware and Parallel Software 15

    2.1 Some Background15

    2.1.1 The von Neumann architecture 15

    2.1.2 Processes, multitasking, and threads 17

    2.2 Modifications to the von Neumann Model 18

    2.2.1 The basics of caching 19

    2.2.2 Cache mappings 20

    2.2.3 Caches and programs: an example 22

    2.2.4 Virtual memory 23

    2.2.5 Instruction-level parallelism 25

    2.2.6 Hardware multithreading 28

    2.3 Parallel Hardware 29

    2.3.1 SIMD systems 29

    2.3.2 MIMD systems 32

    2.3.3 Interconnection networks 35

    2.3.4 Cache coherence 43

    2.3.5 Shared-memory versus distributed-memory 46

    2.4 Parallel Software 47

    2.4.1 Caveats 47

    2.4.2 Coordinating the processes/threads 48

    2.4.3 Shared-memory 49

    2.4.4 Distributed-memory 53

    2.4.5 Programming hybrid systems 56

    2.5 Input and Output 56

    2.6 Performance 58

    2.6.1 Speedup and efficiency 58

    2.6.2 Amdahl’s law 61

    2.6.3 Scalability 62

    2.6.4 Taking timings 63

    2.7 Parallel Program Design 65

    2.7.1 An example 66

    2.8 Writing and Running Parallel Programs 70

    2.9 Assumptions 70

    2.10 Summary 71

    2.10.1 Serial systems 71

    2.10.2 Parallel hardware 73

    2.10.3 Parallel software 74

    2.10.4 Input and output 75

    2.10.5 Performance 75

    2.10.6 Parallel program design 76

    2.10.7 Assumptions 76

    2.11 Exercises 77

    CHAPTER 3 Distributed-Memory Programming with MPI 83

    3.1 Getting Started84

    3.1.1 Compilation and execution 84

    3.1.2 MPI programs 86

    3.1.3 MPI Init and MPI Finalize 86

    3.1.4 Communicators, MPI Comm size and MPI Comm rank 87

    3.1.5 SPMD programs 88

    3.1.6 Communication 88

    3.1.7 MPI Send 88

    3.1.8 MPI Recv 90

    3.1.9 Message matching 91

    3.1.10 The status p argument 92

    3.1.11 Semantics of MPI Send and MPI Recv 93

    3.1.12 Some potential pitfalls 94

    3.2 The Trapezoidal Rule in MPI 94

    3.2.1 The trapezoidal rule 94

    3.2.2 Parallelizing the trapezoidal rule 96

    Contents xiii

    3.3 Dealing with I/O 97

    3.3.1 Output 97

    3.3.2 Input 100

    3.4 Collective Communication101

    3.4.1 Tree-structured communication 102

    3.4.2 MPI Reduce 103

    3.4.3 Collective vspoint-to-point communications 105

    3.4.4 MPI Allreduce 106

    3.4.5 Broadcast 106

    3.4.6 Data distributions 109

    3.4.7 Scatter 110

    3.4.8 Gather 112

    3.4.9 Allgather 113

    3.5 MPI Derived Datatypes 116

    3.6 Performance Evaluation of MPI Programs119

    3.6.1 Taking timings 119

    3.6.2 Results 122

    3.6.3 Speedup and efficiency 125

    3.6.4 Scalability 126

    3.7 A Parallel Sorting Algorithm 127

    3.7.1 Some simple serial sorting algorithms 127

    3.7.2 Parallel odd-even transposition sort 129

    3.7.3 Safety in MPI programs 132

    3.7.4 Final details of parallel odd-even sort 134

    3.8 Summary 136

    3.9 Exercises 140

    3.10 Programming Assignments 147

    CHAPTER 4 Shared-Memory Programming with Pthreads 151

    4.1 Processes, Threads, and Pthreads 151

    4.2 Hello, World 153

    4.2.1 Execution 153

    4.2.2 Preliminaries 155

    4.2.3 Starting the threads 156

    4.2.4 Running the threads 157

    4.2.5 Stopping the threads 158

    4.2.6 Error checking 158

    4.2.7 Other approaches to thread startup159

    4.3 Matrix-Vector Multiplication 159

    4.4 Critical Sections 162

    xiv Contents

    4.5 Busy-Waiting 165

    4.6 Mutexes 168

    4.7 Producer-Consumer Synchronization and Semaphores171

    4.8 Barriers and Condition Variables 176

    4.8.1 Busy-waiting and a mutex 177

    4.8.2 Semaphores 177

    4.8.3 Condition variables 179

    4.8.4 Pthreads barriers 181

    4.9 Read-Write Locks 181

    4.9.1 Linked list functions 181

    4.9.2 A multi-threaded linked list 183

    4.9.3 Pthreads read-write locks 187

    4.9.4 Performance of the various implementations 188

    4.9.5 Implementing read-write locks 190

    4.10 Caches, Cache Coherence, and False Sharing 190

    4.11 Thread-Safety 195

    4.11.1 Incorrect programs can produce correct output

    展开全文
  • 并行程序设计导论> 一些笔记与思考 ,后续基本都会同步到知乎~这两天重新看了《并行程序设计导论》,以前看过编程范式里的一些泛型编程,对于编程模型有些浅薄的思路,趁机记录一下。有经验的大神可以直接跳到第...

    3eca8faff91ac47d5890c04221ac0b18.png

    个人blog原址:<并行程序设计导论> 一些笔记与思考 ,后续基本都会同步到知乎~

    这两天重新看了《并行程序设计导论》,以前看过编程范式里的一些泛型编程,对于编程模型有些浅薄的思路,趁机记录一下。有经验的大神可以直接跳到第四部分看看本鶸的一些思路。


    一、背景介绍

    计算机比较原始的三大领域:存储通讯计算

    几年前老大做了分布式存储,去年做了异步通信,最近他要做并行计算了。

    于是我上周学着以前做过的MIT 6.824课设的做法给做了个demo,老大不满意,说这个模型不希望上来就考虑存储,要把最抽象的语义提炼出来。我想了想,这其实就是hadoop与MPI的关系。

    同样作为分布式框架,MPI的想法是计算和存储分离的,而hadoop因为有hdfs,所以属于计算向存储的迁移。可以说后者是前者的演进,但是MPI更为通用。

    我们的workflow里的算法工厂一直秉承着这样的设计思想:所有基本算法任务都是符合通用算法的,进而在上面做行为派生。那么在我们想设计一类基本算法任务(比如排序、合并、归约),它的最小需求集是什么?

    带着这个问题我看着书写了如下笔记与思考。

    二、本书纲要

    我看的英文版,几大章节分别是:

    Chapter 1 Why Parallel Computing?

    Chapter 2 Parallel Hardware and Parallel Software

    Chapter 3 Distributed-Memory Programming with MPI

    Chapter 4 Shared-Memory Programming with Pthreads

    Chapter 5 Shared-Memory Programming with OpenMP

    Chapter 6 Parallel Program Development

    可以看到,并行计算可以按照内存中的并行或者分布式机器上的并行进行划分。本书介绍的pthreads,OpenMP,还有先前从入门到放弃的cuda编程都是属于前者,而MPI hadoop spark都属于后者。

    第六章里有非常实用的例子是分别用这两种类型的编程思想去拆解n体问题和树型搜索问题。

    三、MPI基本笔记

    1. 启动

    MPI是纯数据消息传递的,所有节点执行相同的代码,由执行时附带的参数来指定全局个数:

    // 编译由mpicc为C编译器包了一层
    mpicc -g -Wall -o mpi_hello mip_hello.o
    
    // 起4个一样的程序作为一个小并行集群
    mpiexec -n 4 ./mpi_hello
    

    并行的语句都会写在MPI_Init(&argc, &argv)MPI_Finalize()之间。

    2. Communicator

    既然是基于消息传递,MPI_Comm就很重要了,它是内部的通信器,从它那可以那到全局整体个数comm_sz和自己是第几个的my_rank,全局Communicator可以通过MPI_COMM_WORLD拿到。my_rank范围是0 ~ comm_sz - 1。

    3. Send and Recv

    直接看两个程序如何做收发:

    // called by process q
    MPI_Send(send_buf_p, send_buf_sz, send_type, dest, send_tag, send_comm);
    
    // called by process r
    MPI_Recv(recv_buf_p, recv_buf_sz, recv_type, src, recv_tag, recv_comm, &status);
    

    则q发送r可以收到的条件至少满足:

    • recv_comm == send_comm
    • recv_tag == send_tag
    • dest == r
    • src == q

    收发消息的语义上两个重要的点:

    1. 点到点之间的消息保序,但是全局不保序。(这个最简单的做法大概是每个点之间建立一个连接就可以了,如果要连接池,则对同一个target要分配一个队列去管理来做到保序)
    2. MPI_Send()包括了bufferblock模式,应该就是我们的非阻塞与阻塞模式,而MPI_Recv()则总是等着的,所以这对于用户的编程要求其实很高,当然灵活度也很高,即你可能因为Recv不到东西而hang住,或者Send的东西没人收而会丢失。

    4. collective communication

    点对点发送只是一种简单的模式,还有没有其他模式呢?collective communication就是了。不太好翻译这个应该叫什么,意思是所有人都要参与计算、并最终由一个人去收集的通信模式(相比之下,send-recv的模式是point-to-point)。感觉现在才正式进入并行计算的用法。

    我们先借用我们最熟悉的归约来做详解:

    int MPI_Reduce(
        void *          input_data_p,
        void *          output_data_p,
        int             count,
        MPI_Datatype    data_type,       // MPI内部的char,int之类
        MPI_Op          operator,        // 内部提供了MAX SUM,还可以自行派生实现
        int             dest_process,    // 大家计算完发给一个人去收集
        MPI_Comm        communicator
    );
    

    一些特点:

    • 所有人都调用同样的collective函数(比如不能有人在这一步做reduce有人做recv);
    • 所有人指定的这一轮的收集者必须是同一个;
    • 虽然只有收集的那个人需要output,但大家都要传;
    • send-recv模式有tag去指定,而collective communication没有,所以这里是通过communicator来寻找collect的节点们的对应关系的,并通过函数调用的顺序(而非参数本身)来决定结果。

    其他类似的api还有:

    MPI_Allreduce(): 这个跟reduce比没有dest_process,即每个人都可以收集结果数据;

    MPI_Bcast(): 参数只有input,没有output,顾名思义,把input发给所有人;

    5. data distribution

    这个有点类似我们做cuda编程时的分thread、分block概念,对于一份数据,我们必须很清晰它可以如何被并行处理,分块方式有block partitioncyclic partitionblock-cyclic partition,概念很简单不细介绍,重点介绍下这个api,可以自动为我们把数据分comm_sz份分发:

    int MPI_Scatter(
        void*           send_buf_p,
        int             send_count,     // 这个send_count可以不被comm_sz整除
        MPI_Datatype    send_type,
        void*           recv_buf_p,
        int             recv_count,
        MPI_Datatype    recv_type,
        int             src_process,    // 由哪号节点分发
        MPI_Comm        comm
    );
    

    与之对称的功能就是MPI_Gather()了,对应的参数时dest_process,指定由哪个节点做收集。通过buf数组的索引可以拿到具体的要分发给某个节点/来自某个节点的数据。

    四、一些想象

    第三章的重要概念就介绍完了,以下是我基于这些外层所想象的一些实现,这些思考不一定都是对的。

    1. communicator通信管理

    这个communicator看上去可以得知所有节点的ip:port,有点像侵入式的服务发现,mpi自身是个框架很容易做这个事情,类似于workflow的client端的upstream。

    2. MPI_Send()/MPI_Recv()的错误处理

    对用户的编程要求是比较高的,但是框架可以做一些事情来发现Send的数据没人收或者等在Recv上卡住的事情。对于workflow来说可以是接收时设置receive_timeout,send没人接收更简单,错误会在callback()返回给用户。再长远点来说,如果我们接管了语言层面,或许还可以在用户编译阶段画出DAG提前分析出这样的错误情况。

    3. DAG

    其实所有的计算步骤都是可以画成DAG的,从DAG的依赖上就很清楚可以看出哪些步骤可以并行。workflow现在的异步任务调度也是通用的道理,只是目前只能算shared-memory的parallel programming,所以才需要进一步提取像MPI这样的接口来为用户封装更抽象的并行计算模型。

    4. 泛型编程

    以前看过一系列泛型编程的文章,提到C++对于泛型的进一步抽象,与MPI面对的问题是比较像的,另外加上google的mapreduce的paper也提到过。我在此总结了下是包括这三点:迭代器、operator、归约函数

    举个例子,以上的MPI_Reduce中接口都可以这样映射到C++中实现:

    template<class DATA_ITERATOR, class DATA_TYPE, class OPERATOR>
    int cpp_reduce(DATA_ITERATOR i_begin,      // 由于数据不一定是数组遍历,
                   DATA_ITERATOR i_end,        // 所以需要input_data的迭代器begin和end
                   DATA_ITERATOR o_begin,
                   /* DATA_ITERATOR o_end, */
                   DATA_TYPE data_default,     // 基本的数据初始化类型
                   OPERATOR op,                // 基本的MAX SUM,也可以自定义
                   int dest_process,           // 大家计算完发给一个人去收集
                   Communicator *comm)
    {
        DATA_TYPE data = data_default;
        DATA_ITERATOR in_iter = i_begin;
        DATA_ITERATOR out_iter = o_begin;
    
        while (in_iter != i_end)
        {
            data = op(*in_iter);
            if (data == data_default)
                return -1;
    
            *out_iter = std::move(data);
            out_iter++;
            in_iter++;
        }
    
        return comm->send(dest_process, o_begin, out_iter);
    }
    
    // 对比看下
    int MPI_Reduce(
        void *          input_data_p,
        void *          output_data_p,
        int             count,
        MPI_Datatype    data_type,       // MPI内部的char,int之类
        MPI_Op          operator,        // 内部提供了MAX SUM,还可以自行派生实现
        int             dest_process,    // 大家计算完发给一个人去收集
        MPI_Comm        communicator
    );
    

    这么写完发现MPI有些接口是不太通用的,比如input_data和output_data的类型和个数都必须一致。这些在我们做自己的算法任务时必须去想清楚。

    五、最后

    事实进一步证明,欠下的技术债迟早都要还。这本书印象很深刻三年前就很喜欢,去夏威夷旅游的时候还非要带在身边,然而根本没有消化。其实这本书对于三年前的我来说还是太抽象了。

    现在我比较适合看的书,必须能有一些定义引领我的思路,然后最重要是不要太具体,能给我留有充分的想象空间,让我去思考现有的东西如何实现,或者我是否还需要开发新的东西去实现这样的模型/机制。而这本书现在看就正正好。昨晚看了一宿兴奋得没睡。最近杂事多,只能草草记录。希望最近能抓紧把这本书消化完,充分想象并行计算。

    展开全文
  • 内容简介《并行程序设计导论》全面涵盖了并行软件和硬件的方方面面,深入浅出地介绍如何使用MPI(分布式内存编程)、Pthreads和OpenMP(共享内存编程)编写高效的并行程序。各章节包含了难易程度不同的编程习题。《并行...

    内容简介

    《并行程序设计导论》全面涵盖了并行软件和硬件的方方面面,深入浅出地介绍如何使用MPI(分布式内存编程)、Pthreads和OpenMP(共享内存编程)编写高效的并行程序。各章节包含了难易程度不同的编程习题。《并行程序设计导论》可以用做计算机科学专业低年级本科生的专业课程的教材,也可以作为软件开发人员学习并行程序设计的专业参考书。

    目录

    出版者的话

    译者序

    本书赞誉

    前言

    致谢

    第1章 为什么要并行计算

    1.1 为什么需要不断提升的性能

    1.2 为什么需要构建并行系统

    1.3 为什么需要编写并行程序

    1.4 怎样编写并行程序

    1.5 我们将做什么

    1.6 并发、并行、分布式

    1.7 本书的其余部分

    1.8 警告

    1.9 字体约定

    1.10 小结

    1.11 习题

    第2章 并行硬件和并行软件

    2.1 背景知识

    2.1.1 冯·诺依曼结构

    2.1.2 进程、多任务及线程

    2.2 对冯·诺依曼模型的改进

    2.2.1 Cache基础知识

    2.2.2 Cache映射

    2.2.3 Cache和程序:一个实例

    2.2.4 虚拟存储器

    2.2.5 指令级并行

    2.2.6 硬件多线程

    2.3 并行硬件

    2.3.1 SIMD系统

    2.3.2 MIMD系统

    2.3.3 互连网络

    2.3.4 Cache一致性

    2.3.5 共享内存与分布式内存

    2.4 并行软件

    2.4.1 注意事项

    2.4.2 进程或线程的协调

    2.4.3 共享内存

    2.4.4 分布式内存

    2.4.5 混合系统编程

    2.5 输入和输出

    2.6 性能

    2.6.1 加速比和效率

    2.6.2 阿姆达尔定律

    2.6.3 可扩展性

    2.6.4 计时

    2.7 并行程序设计

    2.8 编写和运行并行程序

    2.9 假设

    2.10 小结

    2.10.1 串行系统

    2.10.2 并行硬件

    2.10.3 并行软件

    2.10.4 输入和输出

    2.10.5 性能

    2.10.6 并行程序设计

    2.10.7 假设

    2.11 习题

    第3章 用MPI进行分布式内存编程

    3.1 预备知识

    3.1.1 编译与执行

    3.1.2 MPI程序

    3.1.3 MPI_Init和MPI_Finalize

    3.1.4 通信子、MPI_Comm_size和MPI_Comm_rank

    3.1.5 SPMD程序

    3.1.6 通信

    3.1.7 MPI_Send

    3.1.8 MPI_Recv

    3.1.9 消息匹配

    3.1.10 status_p参数

    3.1.11 MPI_Send和MPI_Recv的语义

    3.1.12 潜在的陷阱

    3.2 用MPI来实现梯形积分法

    3.2.1 梯形积分法

    3.2.2 并行化梯形积分法

    3.3 I/O处理

    3.3.1 输出

    3.3.2 输入

    3.4 集合通信

    3.4.1 树形结构通信

    3.4.2 MPI_Reduce

    3.4.3 集合通信与点对点通信

    3.4.4 MPI_Allreduce

    3.4.5 广播

    3.4.6 数据分发

    3.4.7 散射

    3.4.8 聚集

    3.4.9 全局聚集

    3.5 MPI的派生数据类型

    3.6 MPI程序的性能评估

    3.6.1 计时

    3.6.2 结果

    3.6.3 加速比和效率

    3.6.4 可扩展性

    3.7 并行排序算法

    3.7.1 简单的串行排序算法

    3.7.2 并行奇偶交换排序

    3.7.3 MPI程序的安全性

    3.7.4 并行奇偶交换排序算法的重要内容

    3.8 小结

    3.9 习题

    3.10 编程作业

    第4章 用Pthreads进行共享内存编程

    4.1 进程、线程和Pthreads

    4.2 “Hello,World”程序

    4.2.1 执行

    4.2.2 准备工作

    4.2.3 启动线程

    4.2.4 运行线程

    4.2.5 停止线程

    4.2.6 错误检查

    4.2.7 启动线程的其他方法

    4.3 矩阵-向量乘法

    4.4 临界区

    4.5 忙等待

    4.6 互斥量

    4.7 生产者-消费者同步和信号量

    4.8 路障和条件变量

    4.8.1 忙等待和互斥量

    4.8.2 信号量

    4.8.3 条件变量

    4.8.4 Pthreads路障

    4.9 读写锁

    4.9.1 链表函数

    4.9.2 多线程链表

    4.9.3 Pthreads读写锁

    4.9.4 不同实现方案的性能

    4.9.5 实现读写锁

    4.10 缓存、缓存一致性和伪共享

    4.11 线程安全性

    4.12 小结

    4.13 习题

    4.14 编程作业

    第5章 用OpenMP进行共享内存编程

    5.1 预备知识

    5.1.1 编译和运行OpenMP程序

    5.1.2 程序

    5.1.3 错误检查

    5.2 梯形积分法

    5.3 变量的作用域

    5.4 归约子句

    5.5 parallelfor指令

    5.5.1 警告

    5.5.2 数据依赖性

    5.5.3 寻找循环依赖

    5.5.4 π值估计

    5.5.5 关于作用域的更多问题

    5.6 更多关于OpenMP的循环:排序

    5.6.1 冒泡排序

    5.6.2 奇偶变换排序

    5.7 循环调度

    5.7.1 schedule子句

    5.7.2 static调度类型

    5.7.3 dynamic和guided调度类型

    5.7.4 runtime调度类型

    5.7.5 调度选择

    5.8 生产者和消费者问题

    5.8.1 队列

    5.8.2 消息传递

    5.8.3 发送消息

    5.8.4 接收消息

    5.8.5 终止检测

    5.8.6 启动

    5.8.7 atomic指令

    5.8.8 临界区和锁

    5.8.9 在消息传递程序中使用锁

    5.8.10 critical指令、atomic指令、锁的比较

    5.8.11 经验

    5.9 缓存、缓存一致性、伪共享

    5.10 线程安全性

    5.11 小结

    5.12 习题

    5.13 编程作业

    第6章 并行程序开发

    6.1 n体问题的两种解决方法

    6.1.1 问题

    6.1.2 两个串行程序

    6.1.3 并行化n体算法

    6.1.4 关于I/O

    6.1.5 用OpenMP并行化基本算法

    6.1.6 用OpenMP并行化简化算法

    6.1.7 评估OpenMP程序

    6.1.8 用Pthreads并行化算法

    6.1.9 用MPI并行化基本算法

    6.1.10 用MPI并行化简化算法

    6.1.11 MPI程序的性能

    6.2 树形搜索

    6.2.1 递归的深度优先搜索

    6.2.2 非递归的深度优先搜索

    6.2.3 串行实现所用的数据结构

    6.2.4 串行实现的性能

    6.2.5 树形搜索的并行化

    6.2.6 采用Pthreads实现的静态并行化树搜索

    6.2.7 采用Pthreads实现的动态并行化树搜索

    6.2.8 Pthreads树搜索程序的评估

    6.2.9 采用OpenMp实现的并行化树搜索程序

    6.2.10 OpenMp实现的性能

    6.2.11采用MPI和静态划分来实现树搜索

    6.2.12 采用MPI和动态划分来实现树搜索

    6.3 忠告

    6.4 选择哪个API

    6.5 小结

    6.5.1 Pthreads和OpenMP

    6.5.2 MPI

    6.6 习题

    6.7 编程作业

    第7章 接下来的学习方向

    参考文献

    索引

    前言/序言

    并行程序设计导论 [An Introduction to Parallel Programming] 下载 mobi epub pdf txt 格式

    展开全文
  • 并行程序设计导论
  • 并行程序设计导论 基本术语 (Basic Terminology) Before we start the technicalities of our topic, let us understand some very basics. 在开始本主题的技术介绍之前,让我们了解一些非常基础的知识。 What is ...

    并行程序设计导论

    基本术语 (Basic Terminology)

    Before we start the technicalities of our topic, let us understand some very basics.

    在开始本主题的技术介绍之前,让我们了解一些非常基础的知识。

    • What is Programming?

      什么是编程?
    • Instructing the computer to do some task by telling it “What to do” and “How to do it” is programming. It is the medium by which instructions are passed to the computer.

      通过告诉计算机“做什么”“如何 做”来指示计算机执行某些任务。 它是将指令传递到计算机的媒介。

    • What is Programming Language?

      什么是编程语言?
    • Humans use language(s) to communicate with each other. Similarly, the medium used to communicate with the computer to tell “What to do and How to do it” is known as Programming Language.

      人类使用一种或多种语言相互交流。 同样,用于与计算机进行通信以告知“该做什么和怎么做”的介质也称为编程语言。

    • Why Programming Language ?

      为什么要编程语言?
    • Computers can understand only Binary Language consisting of huge combinations of “0”s and “1”s which is definitely not easy for humans to understand. Programming Language(s) are more readable for humans as they use English alphabets and words, Numbers, Symbols.
      A software tool called as “compiler”, which is basically a translator, converts the Human Readable Programming Language into Binary Language which computer can understand.

      计算机只能理解由“ 0”和“ 1”的巨大组合组成的二进制语言,这对人类来说绝对不容易理解。 编程语言对于人类更易读,因为他们使用英文字母和单词,数字,符号。
      基本上是翻译器的一种称为“编译器”的软件工具,将人类可读的编程语言转换为计算机可以理解的二进制语言

    什么是C编程? (What is C Programming?)

    C is one of the Programming Language(s) which revolutionized the world of Computers. Dennis Ritchie created the language at Bell Labs and it appeared in 1972. Since then, it is one of the most popular and widely used languages in millions of devices.

    C是彻底改变计算机世界的一种编程语言。 丹尼斯·里奇(Dennis Ritchie)在贝尔实验室创建了该语言,并于1972年出现。从那时起,它是数百万种设备中最受欢迎和使用最广泛的语言之一。

    C语言编程的特点 (Features of C Programming)

    1. Easy to Code

      易于编码
    2. Strongly Typed

      强类型
    3. Compiled Language

      编译语言
    4. High Performance and Reliable

      高性能可靠
    5. Close to Hardware Compiled Code

      接近硬件编译代码
    6. Procedure Oriented Programming (POP)

      面向过程的编程(POP)

    C程序设计的应用 (Applications of C Programming)

    1. Device Drivers

      设备驱动程序
    2. Kernel of Operating Systems

      操作系统内核
    3. System Programming

      系统程式设计
    4. Embedded Computer and System Applications like “Traffic Light Controllers”

      嵌入式计算机和系统应用程序,例如“交通灯控制器”
    5. Compilers of other Language(s) such as Python, Pearl etc.

      其他语言的编译器,例如Python ,Pearl等。
    6. Heavy Computing tools such as “MATLAB” or “Mathematica”

      重型计算工具,例如“ MATLAB”“ Mathematica”

    C编程的历史 (History of C Programming)

    This paragraph is written like a story for the purpose of abstract and conceptual understanding. It’s okay to skip this section for now and proceed further, as this is discussing about How C came into picture and established and not any technical content required for programming in C. The following information is not sufficient for in-depth technicalities and detailed history.
    出于抽象和概念性理解的目的,本段的内容就像一个故事。 现在可以跳过本节,并继续进行下去,因为这是关于C的形成和发展方式的讨论,而不是C编程所需的任何技术内容。以下信息不足以提供深入的技术知识和详细的历史记录。

    In the late 1960s, when computer hardware got “Transistors” and “ICs (Integrated Circuits)” Assembly Language, FORTRAN, COBOL etc. were being used. Although these languages were serving the purpose at the time to an extent, they had limitations.

    在1960年代后期,当计算机硬件获得“晶体管”和“ IC(集成电路)”时,就使用了汇编语言,FORTRAN,COBOL等。 尽管这些语言在某种程度上达到了当时的目的,但它们有局限性。

    For example, Assembly Language had vast abilities but hard to code, especially when programs become larger. Other languages Such as COBOL, PASCAL were easy and User-Friendly Programming Language(s) but had limited capabilities, i.e. programmer could use only pre-defined features but may not create the desired one.

    例如,汇编语言具有强大的功能,但很难编写代码,尤其是在程序变大时。 其他语言(如COBOL,PASCAL)虽然简单易用,但对用户友好,但功能有限,即程序员只能使用预定义的功能,而不能创建所需的功能。

    At Bell Labs, “Dennis Ritchie” (Computer Scientist) looked at the scenario and came up with an idea to create something with vast capabilities like Assembly Language and User-Friendly.

    在贝尔实验室,“ Dennis Ritchie”(计算机科学家)研究了这种情况,并提出了创建具有汇编语言和用户友好性之类功能的想法。

    The idea said, “Give all possible capabilities within the language which are required frequently and the power to create if it is not present”.

    这个想法说:“在语言中提供经常需要的所有可能的功能,以及如果不存在,则具有创建的能力”。

    The idea devolved as “C Programming Language” and the power given to it was “Control Structure”.

    这个想法演变为“ C编程语言”,赋予它的力量是“控制结构”。

    Initially, C Compiler was programmed in Assembly Language. C uses simple English words, numbers and symbols as required, making it easily readable and understandable for humans.

    最初,C编译器是用汇编语言编程的。 C根据需要使用简单的英语单词,数字和符号,使人类易于阅读和理解。

    UNIX OS was also being developed at Bell Labs and Dennis Ritchie re-programmed the code for “C compiler”, “UNIX OS”, System and Application programs in C language itself and compiled. Thus, performance enhanced significantly as there was no explicit translation because from OS to Application programs, everything was in C. This resulted in quick and wide adaptability of C Programming Language.

    贝尔实验室也在开发UNIX OS,Dennis Ritchie用C语言本身对“ C编译器”,“ UNIX OS”,系统和应用程序的代码进行了重新编程,然后进行了编译。 因此,由于没有显式转换,因此性能得到了显着提高,因为从OS到应用程序,所有内容都在C中。这导致C编程语言具有快速而广泛的适应性。

    摘要 (Summary)

    As a result, the wide applications and features of C make it a very essential and irreplaceable language for computers. For any individual entering in Programming and Development, it is highly recommended to start with C Programming because no other language can show the depths and understanding of programming as clearly as C.

    结果,C的广泛应用和功能使其成为计算机中非常重要且不可替代的语言。 对于进入程序设计和开发的任何个人,强烈建议从C编程开始,因为没有其他语言能够像C一样清楚地显示出对编程的深度和理解。

    References: Wikipedia Article

    参考: 维基百科文章

    翻译自: https://www.journaldev.com/25129/introduction-to-c-programming

    并行程序设计导论

    展开全文
  • 并行程序设计导论课后答案,机械工业,中文翻译教材,英文版,讲解详细,含有代码。
  • 为什么要构建并行系统我们暂时将计算机的处理单元称之为“核”,想要提升一个“核”的运算速度,最基本的方式就是增加集成电路晶体管密度,但是这样在增加运算速度的同时也增加了热量的散失,并且在当今时代用空气...
  • 使用OpenMP需要在编译器上打开OpenMP开关,并包含omp.h文件。我使用的是在Windows下的Visual Studio 2015,只需在工程选项中打开OpenMP支持就可以了。... 参考书籍:并行程序设计导论(英文版),机械工业出版社。
  • 并行程序设计导论 Pacheco 里面提供的编程勘误表 errata。从官网上下载的。
  • 并行程序设计导论》一书的概论部分 主要内容为为什么并行计算,怎样编写并行计算,并行、并发、分布等内容
  • 并行程序设计导论> 一些笔记与思考 ,后续基本都会同步到知乎~这两天重新看了《并行程序设计导论》,以前看过编程范式里的一些泛型编程,对于编程模型有些浅薄的思路,趁机记录一下。有经验的大神可以直接跳到第...
  • 并行程序设计导论笔记 第一章 1.为什么要构建并行系统? 电路晶体管密度过大会使处理器能耗增加,散热的问题使通过继续增快集成电路密度提高处理器性能不再现实,因此集成电路商决定构建多核处理器。 2.为什么要编写...
  • 并行程序设计导论》第三章:       用MPI进行分布式内存编程-教程01                一、学习的大致内容:   1. MPI概述   2. MPI实现   3. 终极测试
  • 本文所写内容是根据《并行程序设计导论》第三章中的矩阵向量乘法代码总结而来的完整代码。 完整代码如下Mat_vect_mult.c #include<stdio.h> #include<mpi.h> #include<stdlib.h> void Get_...
  • 并行程序设计导论》第三章: #      用MPI进行分布式内存编程-教程05                ###并行归并排序参考答案: /* File: * parallelMerge.c * * Author: * E2MCC * * ...
  • 并行程序设计导论》第三章:       用MPI进行分布式内存编程-教程03               (湖南大学并行计算项目组内部学习资料) 三、MPI实现 4.集合通信 (1)广播: MPI_Bcast函数 函数原型: int...
  • 并行程序设计导论》第三章:       用MPI进行分布式内存编程-教程04               (湖南大学并行计算项目组内部学习资料) 三、MPI实现 5.集合操作通信 (1): MPI_Reduce函数 函数原型: ...
  • 并行程序设计导论》第三章:       用MPI进行分布式内存编程-教程02               (湖南大学并行计算项目组内部学习资料) 三、MPI实现 3.点对点通信 (1)发送: MPI_Send函数: 函数原型: ...
  • 并行程序设计导论 Parallel programming should be used any time you have a fair amount of computation work that can be split up into independent chunks. Parallel programming increases the CPU usage ...
  • 并行程序设计导论 第一章习题

    千次阅读 2015-02-08 14:54:11
    这两天也算是找到了这本《并行程序设计导论》,现在准备从最简单的并发的开始。 笔记应该不会做的太多,除非阅读到某些深有感触或有很大疑惑的地方才会写出来。 还有,对于CSDN博客支持markdown格式也是要赞一个...
  • 最近读了《并行程序设计导论》这本书。感觉这本书讲的东西
  • 如何编写并行程序? 任务并行:将待解决问题所需要执行的各个任务分配到各个核上执行 数据并行:将待解决的问题所需要处理的数据分配给各个核,每个核在分配到的数据集上执行大致相似的操作。 协调过程 ...
  • 我们定义a为系统串行执行时间,b为系统并行执行时间,n为处理器个数,F为串行比例,那么系统执行时间(串行时间+并行时间)可以表示为a+ba+ba+b,系统总执行时间(串行时间)可以表示为a+nba+nba+nb,所以有如下公式...
  • 本文是并行程序设计课程学习的笔记总结和回顾。全文按照Peter S. Pacheco 的《An Introduction to Parallel Programming》结构组织。 此博文是学习笔记目录,详细内容根据链接查看对应文章。 ...
  • 这里用了二分法和归并排序 #include <stdio.h> #include<stdlib.h> #include<mpi.h> double* readata(double* data, int n, int my_rank, int comm_sz) { ... fp ...
  • 不支持pragma的编译器就会忽略pragma指令提示的那些语句,这样就允许使用pragma的程序在不支持他们的平台上运行。因此,在理论上,如果你仔细编写一个openmp程序,他就能够在任何有c编译器的系统上被编译和运行,...
  • 把上面的程序写成 global_result=0.0; #pragma omp parallel num_threads(thread_count)\\预处理指令一行写不完就加一个\ { # pragma omp critical gloabl_result+=local_trap(a,b,n);//这样的话对local_trap的...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 195
精华内容 78
关键字:

并行程序设计导论