精华内容
下载资源
问答
  • python并行编程pdf

    2018-06-25 16:54:26
    python并行编程pdf ,多线程技术,多进程技术,python并行编程pdf ,多线程技术,多进程技术
  • Python并行编程手册.pdf

    2019-07-03 08:38:09
    本章将会概述并行编程架构与编程模型。 这些概念对于初次接触并行编程技术、 经验不太丰富的程序员来说非常 有价值。 对于有经验的程序员来说, 本章内容可以作为一个基本的参考。 本章还会介绍并行系统的双重特性。...
  • Xilinx官方翻译的《FPGA并行编程》,本书以10个数字信号处理为例,带我们了解HLS如何使C代码并行运行,深入浅出的将HLS实现方法,硬件设计的考虑 以及系统优化都一一介绍。本书可以在小白仓库微信公众号号免费下载,...
  • 设计模式.net并行编程.pdf 设计模式.net并行编程.pdf 设计模式.net并行编程.pdf
  • 内附C++并行与分布式编程_肖和平2004译.pdf
  • 深入理解并行编程pdf

    2018-02-07 12:15:00
    下载地址:网盘下载内容简介······《深入理解并行编程》首先以霍金提出的两个理论物理限制为引子,解释了多核并行计算兴起的原因,并从硬件的角度阐述并行编程的难题。接着,《深入理解并行编程》以常见的...
    下载地址: 网盘下载

     

     

     

    内容简介  · · · · · ·

    作者简介  · · · · · ·

    Paul E. McKenney is the core contributor of Linux kernel .

    目录  · · · · · ·

    第1章 如何使用本书 1
    1.1 路线图 1
    1.2 小问题 2
    1.3 除本书之外的选择 3
    1.4 示例源代码 4
    1.5 这本书属于谁 4
    第2章 简介 6
    2.1 导致并行编程困难的历史原因 6
    2.2 并行编程的目标 7
    2.2.1 性能 8
    2.2.2 生产率 9
    2.2.3 通用性 9
    2.3 并行编程的替代方案 11
    2.3.1 串行应用的多个实例 11
    2.3.2 使用现有的并行软件 11
    2.3.3 性能优化 12
    2.4 是什么使并行编程变得复杂 12
    2.4.1 分割任务 13
    2.4.2 并行访问控制 13
    2.4.3 资源分割和复制 14
    2.4.4 与硬件的交互 14
    2.4.5 组合使用 14
    2.4.6 语言和环境如何支持这些任务 14
    2.5 本章的讨论 15
    第3章 硬件和它的习惯 16
    3.1 概述 16
    3.1.1 流水线CPU 16
    3.1.2 内存引用 17
    3.1.3 原子操作 18
    3.1.4 内存屏障 19
    3.1.5 高速缓存未命中 19
    3.1.6 I/O操作 19
    3.2 开销 20
    3.2.1 硬件体系结构 20
    3.2.2 操作的开销 21
    3.3 硬件的免费午餐 23
    3.3.1 3D集成 23
    3.3.2 新材料和新工艺 24
    3.3.3 是光,不是电子 24
    3.3.4 专用加速器 24
    3.3.5 现有的并行软件 25
    3.4 对软件设计的启示 25
    第4章 办事的家伙 27
    4.1 脚本语言 27
    4.2 POSIX多进程 28
    4.2.1 POSIX进程创建和销毁 28
    4.2.2 POSIX线程创建和销毁 30
    4.2.3 POSIX锁 31
    4.2.4 POSIX读/写锁 34
    4.3 原子操作 37
    4.4 Linux内核中类似POSIX的操作 38
    4.5 如何选择趁手的工具 39
    第5章 计数 40
    5.1 为什么并发计数不可小看 41
    5.2 统计计数器 42
    5.2.1 设计 43
    5.2.2 基于数组的实现 43
    5.2.3 最终结果一致的实现 44
    5.2.4 基于每线程变量的实现 46
    5.2.5 本节讨论 48
    5.3 近似上限计数器 48
    5.3.1 设计 48
    5.3.2 简单的上限计数实现 50
    5.3.3 关于简单上限计数的讨论 55
    5.3.4 近似上限计数器的实现 55
    5.3.5 关于近似上限计数器的讨论 55
    5.4 精确上限计数 56
    5.4.1 原子上限计数的实现 56
    5.4.2 关于原子上限计数的讨论 62
    5.4.3 Signal-Theft上限计数的设计 62
    5.4.4 Signal-Theft上限计数的实现 63
    5.4.5 关于Signal-Theft上限计数的讨论 68
    5.5 特殊场合的并行计数 68
    5.6 关于并行计数的讨论 69
    5.6.1 并行计数的性能 70
    5.6.2 并行计数的专门化 71
    5.6.3 从并行计数中学到什么 71
    第6章 对分割和同步的设计 73
    6.1 分割练习 73
    6.1.1 哲学家就餐问题 73
    6.1.2 双端队列 75
    6.1.3 关于分割问题示例的讨论 81
    6.2 设计准则 82
    6.3 同步粒度 83
    6.3.1 串行程序 84
    6.3.2 代码锁 85
    6.3.3 数据锁 86
    6.3.4 数据所有权 88
    6.3.5 锁粒度与性能 88
    6.4 并行快速路径 90
    6.4.1 读/写锁 91
    6.4.2 层次锁 91
    6.4.3 资源分配器缓存 92
    6.5 分割之外 97
    6.5.1 使用工作队列的迷宫问题并行解法 97
    6.5.2 另一种迷宫问题的并行解法 100
    6.5.3 性能比较I 102
    6.5.4 另一种迷宫问题的串行解法 104
    6.5.5 性能比较II 104
    6.5.6 未来展望与本节总结 105
    6.6 分割、并行化与优化 106
    第7章 锁 107
    7.1 努力活着 108
    7.1.1 死锁 108
    7.1.2 活锁与饥饿 114
    7.1.3 不公平的锁 116
    7.1.4 低效率的锁 117
    7.2 锁的类型 117
    7.2.1 互斥锁 117
    7.2.2 读/写锁 118
    7.2.3 读/写锁之外 118
    7.2.4 范围锁 119
    7.3 锁在实现中的问题 121
    7.3.1 基于原子交换的互斥锁实现示例 121
    7.3.2 互斥锁的其他实现 122
    7.4 基于锁的存在保证 124
    7.5 锁:是英雄还是恶棍 125
    7.5.1 应用程序中的锁:英雄 125
    7.5.2 并行库中的锁:只是一个工具 126
    7.5.3 并行化串行库时的锁:恶棍 128
    7.6 总结 130
    第8章 数据所有权 131
    8.1 多进程 131
    8.2 部分数据所有权和pthread线程库 132
    8.3 函数输送 132
    8.4 指派线程 132
    8.5 私有化 133
    8.6 数据所有权的其他用途 133
    第9章 延后处理 134
    9.1 引用计数 134
    9.1.1 各种引用计数的实现 135
    9.1.2 危险指针 140
    9.1.3 支持引用计数的Linux原语 141
    9.1.4 计数优化 142
    9.2 顺序锁 142
    9.3 读-复制-修改(RCU) 145
    9.3.1 RCU介绍 145
    9.3.2 RCU基础 147
    9.3.3 RCU用法 155
    9.3.4 Linux内核中的RCU API 166
    9.3.5 “玩具式”的RCU实现 171
    9.3.6 RCU练习 188
    9.4 如何选择? 188
    9.5 更新端怎么办 190
    第10章 数据结构 191
    10.1 从例子入手 191
    10.2 可分割的数据结构 192
    10.2.1 哈希表的设计 192
    10.2.2 哈希表的实现 192
    10.2.3 哈希表的性能 195
    10.3 读侧重的数据结构 197
    10.3.1 受RCU保护的哈希表的实现 197
    10.3.2 受RCU保护的哈希表的性能 199
    10.3.3 对受RCU保护的哈希表的讨论 201
    10.4 不可分割的数据结构 201
    10.4.1 可扩展哈希表的设计 202
    10.4.2 可扩展哈希表的实现 203
    10.4.3 可扩展哈希表的讨论 210
    10.4.4 其他可扩展的哈希表 211
    10.5 其他数据结构 214
    10.6 微优化 214
    10.6.1 实例化 215
    10.6.2 比特与字节 215
    10.6.3 硬件层面的考虑 216
    10.7 总结 217
    第11章 验证 218
    11.1 简介 218
    11.1.1 BUG来自于何处 218
    11.1.2 所需的心态 220
    11.1.3 应该何时开始验证 221
    11.1.4 开源之路 221
    11.2 跟踪 222
    11.3 断言 223
    11.4 静态分析 224
    11.5 代码走查 224
    11.5.1 审查 224
    11.5.2 走查 225
    11.5.3 自查 225
    11.6 几率及海森堡BUG 227
    11.6.1 离散测试统计 228
    11.6.2 滥用离散测试统计 229
    11.6.3 持续测试统计 229
    11.6.4 定位海森堡BUG 232
    11.7 性能评估 235
    11.7.1 性能基准 236
    11.7.2 剖析 236
    11.7.3 差分分析 237
    11.7.4 微基准 237
    11.7.5 隔离 237
    11.7.6 检测干扰 238
    11.8 总结 242
    第12章 形式验证 244
    12.1 通用目的的状态空间搜索 244
    12.1.1 Promela和Spin 244
    12.1.2 如何使用 Promela 249
    12.1.3 Promela 示例: 锁 251
    12.1.4 Promela 示例: QRCU 254
    12.1.5 Promela初试牛刀:dynticks和可抢占RCU 260
    12.1.6 验证可抢占RCU和dynticks 264
    12.2 特定目的的状态空间搜索 288
    12.2.1 解析Litmus测试 289
    12.2.2 Litmus测试意味着什么 290
    12.2.3 运行Litmus测试 291
    12.2.4 PPCMEM讨论 292
    12.3 公理方法 293
    12.4 SAT求解器 294
    12.5 总结 295
    第13章 综合应用 296
    13.1 计数难题 296
    13.1.1 对更新进行计数 296
    13.1.2 对查找进行计数 296
    13.2 使用RCU拯救并行软件性能 297
    13.2.1 RCU和基于每CPU变量的统计计数 297
    13.2.2 RCU及可插拔I/O设备的计数器 300
    13.2.3 数组及长度 300
    13.2.4 相关联的字段 301
    13.3 散列难题 302
    13.3.1 相关联的数据元素 302
    13.3.2 更新友好的哈希表遍历 303
    第14章 高级同步 304
    14.1 避免锁 304
    14.2 内存屏障 304
    14.2.1 内存序及内存屏障 305
    14.2.2 如果B在A后面,并且C在B后面,为什么C不在A后面 306
    14.2.3 变量可以拥有多个值 307
    14.2.4 能信任什么东西 308
    14.2.5 锁实现回顾 312
    14.2.6 一些简单的规则 313
    14.2.7 抽象内存访问模型 314
    14.2.8 设备操作 315
    14.2.9 保证 315
    14.2.10 什么是内存屏障 316
    14.2.11 锁约束 325
    14.2.12 内存屏障示例 326
    14.2.13 CPU缓存的影响 328
    14.2.14 哪里需要内存屏障 329
    14.3 非阻塞同步 329
    14.3.1 简单NBS 330
    14.3.2 NBS讨论 331
    第15章 并行实时计算 332
    15.1 什么是实时计算 332
    15.1.1 软实时 332
    15.1.2 硬实时 333
    15.1.3 现实世界的实时 334
    15.2 谁需要实时计算 336
    15.3 谁需要并行实时计算 337
    15.4 实现并行实时系统 337
    15.4.1 实现并行实时操作系统 339
    15.4.2 实现并行实时应用 349
    15.5 实时VS.快速:如何选择 351
    第16章 易于使用 353
    16.1 简单是什么 353
    16.2 API设计的Rusty准则 353
    16.3 修整Mandelbrot集合 354
    第17章 未来的冲突 357
    17.1 曾经的CPU技术不代表未来 357
    17.1.1 单处理器Uber Alles 358
    17.1.2 多线程Mania 359
    17.1.3 更多类似的场景 359
    17.1.4 撞上内存墙 359
    17.2 事务内存 360
    17.2.1 外部世界 361
    17.2.2 进程修改 364
    17.2.3 同步 367
    17.2.4 讨论 370
    17.3 硬件事务内存 371
    17.3.1 HTM与锁相比的优势 372
    17.3.2 HTM与锁相比的劣势 373
    17.3.3 HTM与增强后的锁机制相比的劣势 379
    17.3.4 HTM最适合的场合 380
    17.3.5 潜在的搅局者 380
    17.3.6 结论 382
    17.4 并行函数式编程 383
    附录A 重要问题 385
    A.1 “After”的含义是什么 385
    A.2 “并发”和“并行”之间的差异是什么 388
    A.3 现在是什么时间 389
    附录B 同步原语 391
    B.1 组织和初始化 391
    B.1.1 smp_init() 391
    B.2 线程创建、销毁及控制 392
    B.2.1 create_thread() 392
    B.2.2 smp_thread_id() 392
    B.2.3 for_each_thread() 392
    B.2.4 for_each_running_thread() 392
    B.2.5 wait_thread() 393
    B.2.6 wait_all_threads() 393
    B.2.7 用法示例 393
    B.3 锁 394
    B.3.1 spin_lock_init() 394
    B.3.2 spin_lock() 394
    B.3.3 spin_trylock() 394
    B.3.4 spin_unlock() 394
    B.3.5 用法示例 395
    B.4 每线程变量 395
    B.4.1 DEFINE_PER_THREAD() 395
    B.4.2 DECLARE_PER_THREAD() 395
    B.4.3 per_thread() 395
    B.4.4 __get_thread_var() 396
    B.4.5 init_per_thread() 396
    B.4.6 用法示例 396
    B.5 性能 396
    附录C 为什么需要内存屏障 397
    C.1 缓存结构 397
    C.2 缓存一致性协议 399
    C.2.1 MESI状态 399
    C.2.2 MESI协议消息 400
    C.2.3 MESI状态图 400
    C.2.4 MESI协议示例 401
    C.3 存储导致不必要的停顿 402
    C.3.1 存储缓冲 403
    C.3.2 存储转发 403
    C.3.3 存储缓冲区及内存屏障 404
    C.4 存储序列导致不必要的停顿 406
    C.4.1 使无效队列 406
    C.4.2 使无效队列及使无效应答 407
    C.4.3 使无效队列及内存屏障 407
    C.5 读和写内存屏障 409
    C.6 内存屏障示例 410
    C.6.1 乱序体系结构 410
    C.6.2 示例1 411
    C.6.3 示例2 412
    C.6.4 示例3 412
    C.7 特定的内存屏障指令 413
    C.7.1 Alpha 414
    C.7.2 AMD64 417
    C.7.3 ARMv7-A/R 417
    C.7.4 IA64 418
    C.7.5 PA-RISC 418
    C.7.6 POWER / Power PC 418
    C.7.7 SPARC RMO、PSO及TSO 419
    C.7.8 x86 420
    C.7.9 zSeries 421
    C.8 内存屏障是永恒的吗 421
    C.9 对硬件设计者的建议 422
    附录D 问题答案 423
    D.1 如何使用本书 423
    D.2 简介 424
    D.3 硬件和它的习惯 427
    D.4 办事的家伙 429
    D.5 计数 433
    D.6 对分割和同步的设计 445
    D.7 锁 449
    D.8 数据所有权 455
    D.9 延迟处理 456
    D.10 数据结构 471
    D.11 验证 473
    D.12 形式验证 478
    D.13 综合应用 481
    D.14 高级同步 483
    D.15 并行实时计算 486
    D.16 易于使用 487
    D.17 未来的冲突 487
    D.18 重要问题 490
    D.19 同步原语 491
    D.20 为什么需要内存屏障 491
    附录E 术语 495
    附录F 感谢 502
    F.1 评审者 502
    F.2 硬件提供者 502
    F.3 原始出处 503
    F.4 图表作者 503
    F.5 其他帮助 505

     

     

     

    下载地址: 网盘下载

     

    转载于:https://www.cnblogs.com/long12365/p/9730686.html

    展开全文
  • 中文文字版,字迹清晰,很不错的多线程编程的书籍
  • opencl代码,具有参考意义,可以看看。。。对我帮助大
  • python并行编程 中文版

    2018-08-24 11:46:34
    本章将介绍一些并行编程的架构和编程模型。对于初次接触并行编程技术的程序员来说,这些都是非常有 用的概念;对于经验丰富的程序员来说,本章可以作为基础参考。 本章中讲述了并行编程的两种解释,第 一种解释是...
  • C#并行编程高级教程(中文版PDF高清).rar C#并行编程高级教程(中文版PDF高清).rar C#并行编程高级教程(中文版PDF高清).rar
  • 《微软技术丛书:Visual Studio 2010并行编程从入门到精通》针对并行编程,沿袭深受读者欢迎的STEP—BY—STEP风格,一次讲授一个知识点,由浅入深地介绍了相关基础知识,如任务并行和数据并行,讨论了并发集合和线程...
  • 以下资料大部分来自《C++并行与分布式编程》,英文版叫《Parallel and Distributed Programming Using C++》。有兴趣的同学可以找来看一下。 1、什么是并发? 如果两个事件是在同一时间间隔内发生的,就说这两个...

    对于并发编程的诸多方法本人一直感觉到混乱,刚好最近看了一些资料,觉得是时候系统的梳理一下了。以下资料大部分来自《C++并行与分布式编程》,英文版叫《Parallel and Distributed Programming Using C++》。有兴趣的同学可以找来看一下。


    1、什么是并发?

    如果两个事件是在同一时间间隔内发生的,就说这两个事件是并发的,两个或多个任务在同一时间间隔内执行叫做并发执行。对于大部分同学来说,最大的混淆在于并发和并行的区别。并行是指多个任务在每时每刻都同时进行,就像电路里面的并联一样。并行要比并发更难得,显然对于单CPU来说,除了指令级别的并行,我们并不能实行精确的并行,除非拥有多个CPU或者多个核。我们的多进程和多线程只能称为是并发。

    2、为什么要并发?

    既然并发并不能实现严格的并行——实际上并发只是看起来是在同一时间间隔内同时执行,但在微观意义可能却还是串行,就像电路里面的串联,那么我们为什么还要并发编程呢?自己骗自己么?哈哈,当然不是,并发编程有很多实际意义的。

    1. 有时并发确实能在同一时间间隔内完成更多的任务,也就是有利于增加任务的吞吐量。因为在单CPU的情况下,并不是所有的任务在进行的每时每刻都使用CPU,也许还要使用IO等设备。而在多CPU或者多台计算机组成的集群的情况下,就更不用说了。
    2. 并发有利于简化程序解决方案。有时把问题的解决方案看作一组并发执行的任务更合理。这是模拟现实场景的自然方式。
    3. 有时对于效能而言速度处于次要地位,采用并发性是为了使软件在相同的时间间隔内做更多的工作。比如一个网站支持多少个用户同时访问。
    4. 最后,采用并发性可以简化软件,通常一系列较短的并发执行操作比一个较长的复杂的顺序操作更容易实现。并发使软件运行速度更快,处理更多的负载或简化程序的设计方案,其主要目标是软件优化,即采用并发性使软件性能更佳。

    3、怎么实现并发?

    并行和分布式编程是达到软件并发的两种基本途径。它们是两种不同的、有时又相互交叉的编程范例。并行编程技术将程序必须处理的作业分配给一个物理或虚拟计算机内的两个或者多个处理器;而分布式编程技术则一般是将作业分配给集群内的不同计算机的一个或者多个处理器。从这个角度讲,分布式编程的范围要比并行编程范围更大。
    并行程序可以分成进程或者线程实现。
    分布式程序仅能分成进程实现。
    在技术上,并行程序有时候是分布式的,例如PVM编程。
    在技术上,分布式编程有时用于实现并行性,例如MPI编程。
    但并非所有的分布式程序都包括并行性,分布式程序的各部分可以在不同时间间隔内的不同时刻执行。
    在纯粹的并行程序中,并发执行部分都是同一个程序中的部分;
    在分布式程序中,并发执行的部分通常实现成分离的程序。

    4、并行编程

    由于并行编程一般是在同一台机器上,通常实现并行编程需要借助专门的硬件。如果是只需要CPU运算的,那么硬件上至少是多个CPU才能实现严格意义的并行。另外,也可以是CPU,显卡,声卡的并行运算。最简单的并行模型是在同一台机器中有多个CPU共享同一个存储器,这个模型拥有互斥读互斥写、互斥读并发写、并发读互斥写、并发读并发写四种基本读写算法,这样才能保证并行执行任务而不会出错。

    5、分布式编程

    分布式编程技术允许软件利用因特网、团体或企业内部网络及广播网上的资源。所有关于一个程序通过某种网络连接与另一个程序的通话都是分布式编程,从这个意义上来讲,我们通常编写B/S架构或者C/S架构的程序都是分布式编程。分布式编程有以下好处:

    1. 分布式编程技术提供对地理上可能相隔很远的资源的访问。比如Web服务;
    2. 分布式编程技术提供对昂贵的硬件和软件资源的共享访问,比如高端全息照相打印机;
    3. 分布式计算可用于冗余和实效的处理,比如服务器的热备份功能通过配置集群来实现;
    4. 分布式编程技术允许用户共享庞大的数据库,比如分布式存储。

    6、并发编程设计过程

    1. 分解。分解是将问题和解决方案划分成多个部分的过程。
    2. 通信。一旦软件解决方案将软件分解成大量的并发执行部分,这些部分通常需要进行一定量的通信。如果各部分之间不进行通信,那么这些部分就不能真正组成一个单独的应用程序。
    3. 同步。当软件的多个构建处理同一个问题时,他们必须进行协调,比如执行顺序的协调,访问资源的协调等等。

    7、C++开发如何实现软件并发

    在应用程序开发中有几种层次的并发,但是我们C++程序编程所涉及到的并发性和操作系统或者硬件的并发性是不同的,尽管硬件的并发和操作系统级的并发支持应用程序的并发,但是我们关注的是应用程序。
    在C++编程实现并行性使用库。系统库和用户库都能用于支持C++中的并行性。

    系统库

    系统库是由操作系统环境提供的库,新的单一UNIX规范中的一部分POSIX线程是对C++并发实现的支持。除指令集并行外,将程序分成线程或进程是获得C++并行性的唯一方法,新规范提供了做这项工作的工具,开发者可以使用:

    • POSIX线程(也称Pthread)
    • POSIX产生函数
    • exec()函数族

    在C++中可以用POSIX线程库进行多线程编程,如果程序在有多个处理器的计算机中运行,那么每个线程可能分别在一个处理器上运行,因此可以并发执行。如果仅有一个处理器可用,那么可以通过进程的上下文切换达到并发并给人一种并行的感觉。POSIX线程可能是在C++程序中引入并行性最简单的方法。

    用户级库

    这些用户级库是实现了另一种国际标准的用户级库,也可以用于支持C++的并行性,主要有:

    • MPI(Message Passing Interface,消息传递接口):是消息传递的标准规范。MPI是为超大规模并行计算机和工作站集群的高性能而设计的。MPICH是MPI标准的一种实现。MPICH给C++编程者提供了一组API和库,这些API和库支持并行编程。尽管C++没有固定的并行性原语,但是它能够利用支持并行性的功能库如MPICH,这就是C++的优点,它是为灵活性而设计的。
    • PVM(Parallel Virtual Machine,虚拟并行计算机):集群编程的一种标准,是一个软件包,它允许一个异构计算机集通过网络连接在一起,使用起来如同一个单独的大规模并行计算机。PVM系统的全部目标是使一个计算机集可以协调工作用于并发或并行计算。PVM是最易于使用、最灵活的可用于基本并行编程任务的平台,这些并行编程任务需要涉及到运行不同操作系统的不同类型的计算机。
    • CORBA(Common Object Request Broker Architecture,公共对象请求代理体系结构):是分布式跨平台面向对象编程的标准。MICO是其一个可免费利用、完全自适应的实现,MICO支持C++。

    使用以上的用户级库需要预先下载获取,他们很容易得到。

    8、并行和分布式编程的编程环境

    最后我们需要关注一下最普遍的并行和分布式编程环境是:

    • 集群:用网络连接到一起,以提供单一逻辑系统的计算机集合。
    • MPP:大规模并行处理器,是具有数百个处理器的一个单独计算机。
    • SMP:对称多处理系统,拥有多个处理器的一个单独系统。

    可见,平时单机单CPU单核的情况下我们编写的并发程序不一定能够真正的并行,并发编程主要还是应用在一定硬件资源编程环境基础上。

    展开全文
  • C#并行编程高级教程 (中文版) 您想淋漓尽致地发挥多核计算机系统的处理能力吗?《c#并行编程高级教程》将帮助您实现这一夙愿。这本精品书籍浓墨重彩地描述如何使用c# 4、visual studio2010和. framework4高效地创建...
  • 消息传递并行编程环境 MPI 一、 进程与消息传递 二、 MPI 环境的应用现状 三、 MPI 并行程序设计入门(程序例 1) 四、 初步的 MPI 消息传递函数 五、 作业一 六、 先进的 MPI 函数 七、 MPI 并行程序示例 2(求解-...
  • [Packt Publishing] OpenCL 并行编程开发 经典实例 (英文版) [Packt Publishing] OpenCL Parallel Programming Development Cookbook (E-Book) ☆ 图书概要:☆ Accelerate your applications and understand ...
  • CUDA开发者社区技术总监亲自撰写,英伟达中国首批CUDA官方认证工程师翻译,译著双馨 全面、详实地讲解了CUDA并行程序设计的技术知识点和编程方法,包含大量实用代码示例,是目前学习CUDA编程最权威的著作之一
  • 并行编程模式

    2018-06-26 05:14:00
    并行编程模式
  • C#多核并行编程很不错的一本书,讲解通俗易懂,讲解很深入,有利于提高编程能力
  • 用 Hadoop 进行分布式并行编程, 第 1 部分 基本概念与安装部署 级别 初级 文档选项 曹 羽中 (caoyuz@, 软件工程师, IBM 中国开发中心 打印本页 2008 年 5 月 22 日 将此页作为电子邮件 Hadoop 是一个实现了 ...
  • java 并行编程

    2015-06-30 21:46:51
    java的并行编程的样例,jdk1.7中并行框架的样例,多种并行的实现方法
  • 首先介绍了并行程序设计的基础提供给读者进行并行程序设计所需要的基本知识然 后介绍了MPI的基本功能从简单的例子入手告诉读者MPI程序设计的基本过程和框架 这一部分是具有C或/FORTRAN串行程序设计经验的人员很容易...
  • OpenMP是由The Board of the OpenMP Architecture Review Board(ARB)提出的一套用于共享内存并行系统的多线程程序设计标准。目前,OpenMP仅支持C、C++和Fortran语言。由于OpenMP是一种共享存储的标准,所以在非...
  • C#并行编程高级教程(中文版).pdf

    热门讨论 2014-08-18 16:20:16
    C#并行编程高级教程(中文版).pdf
  • 本书介绍目前最常见的并行程序—MPI并行程序的设计方法它适合高校三四年级本科 生非计算机专业研究生作为教材和教学自学参考书...算用户作为自学参考书使用对于有FORTRAN和C编程经验的人员都可以阅读并掌握 本书的内容
  • OpenACC并行编程实战

    2019-07-22 18:35:13
    资源名称: OpenACC并行编程实战资源截图: 资源太大,传百度网盘了,链接在附件中,有需要的同学自取。
  • CUDA并行程序设计 GPU编程指南,权威书籍。。。。。。。。。
  • .NET中的并行编程.pdf

    2019-10-25 15:39:07
    .NET的并发任务编程pdf文件,可供学习计算限制的异步操作。需要一定的线程知识基础。计算限制操作常常可用于时间消耗较大的操作。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,286
精华内容 6,514
关键字:

并行编程pdf