精华内容
下载资源
问答
  • MapReduce海量数据并行处理 复习大纲 Ch. 1. 并行计算技术简介 1.为什么需要并行计算 提高计算机性能有哪些基本技术手段 提高字长流水线微体系结构技术提高集成度提升主频 迫切需要发展并行计算技术的主要原因 1)单...
  • Java7之前并行处理数据集合是一件很麻烦的事情:第一步:明确把包含数据数据结构分成若干子部分;第二步,为每一个子部分分配一个线程;第三步,你需要恰当的时候对他们进行同步来避免不出现竞争的条件;第四步,...

    Stream接口可以让你以声明的方式处理数据。同时,用内部迭代取代外部迭代能够让原生Java库控制流元素的处理。


    Java7之前并行处理数据集合是一件很麻烦的事情:第一步:明确把包含数据的数据结构分成若干子部分;第二步,为每一个子部分分配一个线程;第三步,你需要恰当的时候对他们进行同步来避免不出现竞争的条件;第四步,等待所有线程完成,然后把这些部分结果合并起来。

    在本文中你将看到,如何不花大力气来实现对数据集的并行处理。它允许你声明性地将顺序流变为并行流。流是如何在幕后利用JAVA7引入的分支/合并框架

    对收集源调用parallelStream方法把集合转换为并行流。并行流就是把内容分为多个块,并用不同的线程分别处理每个数据块的流。这样一来,你就可以自动把给定操作的工作负荷分配给多核处理器的所有内核,让他们都忙起来。

    package ExeriseAboutSreeam;
    
    import java.util.stream.Stream;
    /*高斯小时候发明了从1+2+3+...+100的简化公式,其实就是今天我们熟悉的等差数列求和问题
     * 现在我们用计算机编程来实现给定任何n,求1+2+3+...+n的和
     */
    public class TheSum {
    	//传统方法实现---外部迭代
    	public static long iterativeSum(long n) {
    		long result = 0;
    		for(long i =1L; i<=result;i++) {
    			result += i;
    		}
    		return result;
    	}
    	
    	//利用流处理来实现----内部迭代
    	public static long sequentialSum(long n) {
    		return Stream.iterate(1L,i -> i+1)
    				.limit(n)
    				.reduce(0L,Long::sum);
    	}
    	
    	//等一等,能不能提高一下计算的效率,假设您的电脑是多核的,怎么利用这太神机?
    	public static long parallelSum(long n) {
    		//利用并行流
    		return Stream.iterate(1L, i -> i+1)
    				.limit(n)
    				.parallel()
    				.reduce(0L, Long ::sum);
    	}
    }

    如果,看不懂后面两种实现方法,请自行补习JAVA8关于Lambda表达式和流处理的相关内容。

    现在,初步体会到并行流的强大作用,可以将数据集划分成若干块,然后利用多核进行多线程同步计算。这样将分配线程、合并结果等工作都抛给了计算机已有的框架。


    效果如何?我们来测试一下,使用并行方式是不是更快?

    package ExeriseAboutSreeam;
    
    import java.util.function.Function;
    import java.util.stream.LongStream;
    import java.util.stream.Stream;
    /*高斯小时候发明了从1+2+3+...+100的简化公式,其实就是今天我们熟悉的等差数列求和问题
     * 现在我们用计算机编程来实现给定任何n,求1+2+3+...+n的和
     */
    public class TheSum {
    	//传统方法实现---外部迭代
    	public static long iterativeSum(long n) {
    		long result = 0;
    		for(long i =1L; i<=result;i++) {
    			result += i;
    		}
    		return result;
    	}
    	
    	//利用流处理来实现----内部迭代
    	public static long sequentialSum(long n) {
    		return Stream.iterate(1L,i -> i+1)
    				.limit(n)
    				.reduce(0L,Long::sum);
    	}
    	
    	//等一等,能不能提高一下计算的效率,假设您的电脑是多核的,怎么利用这台神机?
    	public static long parallelSum(long n) {
    		//利用并行流
    		return Stream.iterate(1L, i -> i+1)
    				.limit(n)
    				.parallel()
    				.reduce(0L, Long ::sum);
    	}
    	//换一个数据结构
    	public static long parallelRangedSum(long n) {
    		return LongStream.rangeClosed(1,n)
    				.parallel()
    				.reduce(0L, Long ::sum);
    				
    	}
    	
    	
    	//测试模块---测流量性能
    	public long measureSumPerf(Function<Long, Long> adder, long n) {
    		long fastest = Long.MAX_VALUE;
    		for(int i =0; i<10 ; i++) {
    			long start = System.nanoTime();
    			long sum = adder.apply(n);
    			long duration = (System.nanoTime() - start) /1_000_000;
    			//System.out.println("结果:" + sum);
    			if(duration < fastest) fastest = duration;
    		}
    		return fastest;
    	}
    	
    	//主函数,测试时间;
    	public static void main(String[] args) {
    		TheSum theSum = new TheSum();
    		System.out.println("方法1测试结果:" + 
    		theSum.measureSumPerf(TheSum::iterativeSum, 10_000_000) + "msecs");
    		
    		System.out.println("方法2测试结果:" + 
    		theSum.measureSumPerf(TheSum::sequentialSum, 10_000_000) + "msecs");
    		
    		System.out.println("方法3测试结果:" + 
    		theSum.measureSumPerf(TheSum::parallelSum, 10_000_000) + "msecs");
    		
    		System.out.println("方法4测试结果:" + 
    		theSum.measureSumPerf(TheSum::parallelRangedSum, 10_000_000) + "msecs");
    		
    	}
    		
    }
    

    测试结果:

    方法1测试结果:0msecs
    方法2测试结果:101msecs
    方法3测试结果:104msecs
    方法4测试结果:2msecs

    结果好像和预想的不一致,利用流和并行并没有比传统的外部迭代方式快。为什么会出现这种情况?其实iterator是不适合做 并行处理的,因为它的每一次迭代都要用前一次的结果,加上装箱和拆箱的损耗,反而更耗时。方法四利用了别的数据结构,代码的时间复杂度明显降了下来。看来要正确使用并行流也不是一件容易的事情,用不好的话,反而弄巧成拙,代码运行起来更慢。

    如何正确使用并行流?

    待更新.......

















    展开全文
  • 在这个教程里,我们将学习如何使用数据并行(DataParallel)来使用多GPU。 PyTorch非常容易的就可以使用GPU,可以用如下方式把一个模型放到GPU上: device = torch.device(&quot;cuda:0&quot;) model.to...

    译者:bat67

    最新版会在译者仓库首先同步。

    在这个教程里,我们将学习如何使用数据并行(DataParallel)来使用多GPU。

    PyTorch非常容易的就可以使用GPU,可以用如下方式把一个模型放到GPU上:

    device = torch.device("cuda:0")
    model.to(device)
    

    然后可以复制所有的张量到GPU上:

    mytensor = my_tensor.to(device)
    

    请注意,调用my_tensor.to(device)返回一个GPU上的my_tensor副本,而不是重写my_tensor。我们需要把它赋值给一个新的张量并在GPU上使用这个张量。

    在多GPU上执行前向和反向传播是自然而然的事。然而,PyTorch默认将只是用一个GPU。你可以使用DataParallel让模型并行运行来轻易的让你的操作在多个GPU上运行。

    model = nn.DataParallel(model)
    

    这是这篇教程背后的核心,我们接下来将更详细的介绍它。

    导入和参数

    导入PyTorch模块和定义参数。

    阅读全文/改进本文

    展开全文
  • python 并行化:加快数据处理

    千次阅读 2019-03-27 15:00:04
    最近在做一个项目,遇到一个比较棘手的问题,那就是在用python 处理数据的时候效率非常低,在查阅了相关问题的同时,学习到不少小窍门,先记录一下供学习。 先给出一些方法,最后结合笔者自己的一个例子看一下实际...

    最近在做一个项目,遇到一个比较棘手的问题,那就是在用python 处理数据的时候效率非常低,在查阅了相关问题的同时,学习到不少小窍门,先记录一下供学习。

    先给出一些方法,最后结合笔者自己的一个例子看一下实际效果

    第一招:

    numba神器
    

    相关资料:文章正在审核中... - 简书

    第二招:

    多进程的使用,不得不说的是为什么不使用多线程,因为多线程其实在python 里面是个表象,其本质上还是切分时间片,所以要想更好的利用其多核cpu,Python的话还是推荐多进程

    主要就是使用了multiprocessing这个包,关于该包的使用网上资料多多,这里就不再多述大家可以查看便是

    实际应用的话主要就是使用了pool池,一般模板的话就是:

    import multiprocessing
    import time
    import os
    print("温馨提示:本机为",os.cpu_count(),"核CPU")  
    
    def func(msg):
        print "msg:", msg
        time.sleep(3)
        print "end"
    
    if __name__ == "__main__":
        #这里开启了4个进程
        pool = multiprocessing.Pool(processes = 4)
        for i in xrange(4):
            msg = "hello %d" %(i)
            pool.apply_async(func, (msg, ))   
    
        pool.close()
        pool.join()   #调用join之前,先调用close函数,否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
        print "Successfully"

     --------------------------------------------------------------------------------------------------------------------------------------------------------------------

    在用python 处理数据的时候,经常需要使用pandas,尤其是需要操作dataframe这个数据结构,比如在机器学习特征工程的时候,需要对某一列(某个特征)做某一种操作(时间转化等等),其实这时候问题就是:

    df.map(func) 而我们知道这种形式其实是非常适合做并行处理的(主要我们这里强调的是并行不是并发),那么就以笔者当前做的事情为例:

    背景:我是要对一个生物分子提取指纹,说白了就是对'ROMol'这一字段下的数据做一定操作

    如果什么优化方法也不加,即使用单进程做的话,大概需要多长时间呢(以处理50个分子为例):

    可以看到大概需要465秒,其实当前待处理的数据量大概是40万,这样算下去的话,大概要。。。。。。。。。呵呵

    那么使用多进程呢?首先将50个分子分片成了10个小文件,即每个文件下有5个分子,然后为每个文件开启一个进程进行处理,相当于开启了10个进程,实验结果如下:

    按理论计算的话,效率应该是提升10被吧,但是这里仅仅提高了大约4.7倍的样子

    ------------------------------------------------------------------------------------------------------------------------------------------------------------------

    效果呢还是有的,但是上面这样貌似还是太麻烦了,还得对文件进行划分,最后使用多进程处理完了得到的应该也是一堆小文件,还得进行合并,尽管拆分和合并的过程很容易就可以写出来

    那么有没有别的方法,就是说直接在dataframe上面进行多线程呢?肯定是有的啦

    这里给出一个讨论:python - Parallelize apply after pandas groupby - Stack Overflow

    大家可以看一下

    笔者将最关键的部分写出来:

    import pandas as pd
    from sklearn.externals.joblib import Parallel, delayed
    from tqdm import tqdm, tqdm_notebook
    tqdm_notebook().pandas()
    
    
    df = pd.read_csv(inputfile)
    df = df.groupby(df.index)
    retlist = Parallel(n_jobs=jobNum)(delayed(youFunc)(group,Funcarg1,Funcarg12) for name, group in tqdm(df))
    df = pd.concat(retlist)

    首先tqdm就是一个进度条,不用多理会

    讨论区使用的源joblib即

    from joblib import Parallel, delayed

    两则用法本无区别,但有时候sklearn继承的Parallel更优化

    jobNum就是要开启的进程数目,youFunc就是自己定义的处理数据函数

    比如说

    def youFunc(df,ops):
        if ops=='add':
            df['c'] = df['a'] + df['b']
        else:
            df['c'] = df['a'] - df['b']
        return df

    这里的df = df.groupby(df.index)

    就是就是为了Parallel中的迭代,当然啦,讨论区也给出了直接使用multiprocessing这个包的做法,大家可以参考

    在使用了这一种方法后,笔者的实验结果大概是1min6s 相比于97秒还是又提了不少。

    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------

    题外话:

    为什么没有成倍的提高效率呢?答案多种多样,网上解释的也是天花烂醉,因为笔者这里的资源是12核,按1:1的话开了12个进程看了下效果:

    大概是61秒的样子,那么随着数据量的增大,带来的效率是不是会更好点呢?

    于是乎又试了下150个分子:

    貌似是会更好点,按50个需要1min计算的话,大概还是会需要5天半,这是何等的。。。。。。。

    其实笔者问题的根源是fun函数中提取指纹这一函数的问题,看了一下,有的分子需要2秒,有的分子居然需要20秒,

    二者有区别吗:

    哈哈哈,扯远了扯远了,,

    --------------------------------------------------------------------------------------------------------------------------------------------------------------

    总结一下本文主题和核心:

    import pandas as pd
    from sklearn.externals.joblib import Parallel, delayed
    from tqdm import tqdm, tqdm_notebook
    tqdm_notebook().pandas()
    
    
    df = pd.read_csv(inputfile)
    df = df.groupby(df.index)
    retlist = Parallel(n_jobs=jobNum)(delayed(youFunc)(group,Funcarg1,Funcarg12) for name, group in tqdm(df))
    df = pd.concat(retlist)

    所以使用这种方法的关键在于怎么构建一个类似迭代器的东西,在daatframe上面是使用了groupby

    -----------------------------------------------------------------------------------------------------------------------------------------

    多说一句:

    这里是对index索引进行了分组,显然index是唯一的,分组之后没有意义,但是带来的好处就是其构成了迭代器,但是有的时候我们可以在此基础上进一步优化,比如现在dataframe有一列特征是动物类别【狗,猪,兔】,假设我们现在的处理是对一种类别进行同一种处理操作,假设对遇到狗时我们进行的特征操作是A,遇到猪时进行的操作是B,试想假如还是上面的代码跑的话,我们是不是重复了很多操作,即有很多都是狗,本来我们只需要进行一次A操作即可,而因为现在是单独对每一个样本都进行处理即相当于重复了很多次A操作,所以我们可以这样优化:

    首先我们处理特征的函数是Transanimal:

    def Transanimal(animal):
            if animal=='dog':
                return A(animal)
            if animal=='pig':
                return B(animal)
             

    比如该对应动物列特征的column 名字是animal,我们现在需要的是通过Transanimal转化,新生产一列假如叫做animal_values吧

    没有优化前:

    import pandas as pd
    from sklearn.externals.joblib import Parallel, delayed
    from tqdm import tqdm, tqdm_notebook
    tqdm_notebook().pandas()
    
    def youFunc(name,df):
        df['animal_values'] = Transanimal(df['animal'])
        return df
    
    
    df = pd.read_csv(inputfile)
    df = df.groupby(df.index)
    retlist = Parallel(n_jobs=jobNum)(delayed(youFunc)(group) for name, group in tqdm(df))
    df = pd.concat(retlist)

    优化后

    import pandas as pd
    from sklearn.externals.joblib import Parallel, delayed
    from tqdm import tqdm, tqdm_notebook
    tqdm_notebook().pandas()
    
    def youFunc(name,df):
        animal_values =  Transanimal(name)
        df['animal_values'] = animal_values
        return df
    
    
    df = pd.read_csv(inputfile)
    df = df.groupby(df['animal'])
    retlist = Parallel(n_jobs=jobNum)(delayed(youFunc)(name,group) for name, group in tqdm(df))
    df = pd.concat(retlist)

    两则对比:

    后者对animal分组后,会将很多是同一组的聚集在一次,而这些数据只需要进行一次Transanimal函数即可

    假设一共有8组,也就是说进行了8次Transanimal

    而没有优化前呢,有多少数据就进行了多少次Transanimal,

    极端一点来说,假设所有数据都是狗这一种类,Transanimal处理过程需要1min,现在样本数是10000条

    那么优化前需要10000min,优化后1min,当前这样计算时间是不准确的,这里仅仅为了对比一下

    Transanimal需要的运行时间越长,组数越小,样本数越多

    这种优化带来的效果越明显

    -----------------------------------------------------------------------------------------------------------------------------------------

    更一般的情况比如说我们处理的数据不是dataframe呢?

    怎么构建一个迭代器呢?

    这时候可能就要相当python中的yield

    假设现在是读一个文件,然后对每一行进行T_T操作

    def _read_file(file_name):
        while True:
            line = file_name.readline()
            if not line:
                break
            yield T_T(line)

    那么

    df = _read_file('animal.txt')

    那么此时df就是一个迭代器啦,有了这个东西我们就又可以愉快的并行化啦:

    retlist = Parallel(n_jobs=jobNum)(delayed(youFunc)(name,group) for name, group in tqdm(df))

    到这里基本就讲完了,切记使用并行化的前提是顺序不重要,比如dataframe,原始的样本索引是0,1,2,3,4这样的

    但处理完后完全有可能变成2,3,0,4,1 所幸的是我们在处理数据尤其是处理特征的时候,我们大多时候是不在乎这样顺序的。

    看到很多小伙伴私信和关注,为了不迷路,欢迎大家关注笔者的微信公众号,会定期发一些关于NLP的干活总结和实践心得,当然别的方向也会发,一起学习:


    ​​​​​​​

     

    展开全文
  • 主要介绍了.Net并行计算之数据并行,有需要的朋友可以参考一下
  • 针对频繁出现的数据冗余、数据复用效率低下等问题,将列存储方式结合并行处理机制对数据复用策略进行优化。构建了基于MapReduce的数据复用并行化处理模型,利用改进型CSM模式匹配算法结合数据挖掘过程中的数据筛选...
  • 针对这一问题,文中提出了并行数据库的海量数据分析处理方法,该方法详细对比了MapReduce和并行数据库技术,然后确定选用并行数据库的方法来处理海量数据。最后在该方法的基础之上,提出了从数据读取到数据处理的...
  • MapReduce是一种处理海量数据并行编程模式,用于大规模数据集(通常大于1TB)的并行运算。
    MapReduce是一种处理海量数据的并行编程模式,用于大规模数据集(通常大于1TB)的并行运算。
    
    “Map(映射)”、“Reduce(化简)”的概念和主要思想,都是从函数式编程语言和矢量编程语言借鉴。
    适合非结构化和结构化的海量数据的搜索、挖掘、分析与机器智能学习等。


    MapReduce计算模型


    分布式计算的瓶颈是网络带宽。“本地计算”是最有效的一种节约网络带宽的手段。


    MapReduce的特点


    1、输入的键值是不固定的,由分析人员选择
    2、对于非结构化和半结构化数据,非常有效
    3、适合于大规模数据的一次写入,多次查询
    4、MapReduce其核心就是高速、流式读写操作


    无共享


    无共享结构让MapReduce程序员无需考虑系统的部分失效问题;
    因为自身的系统实现,能够检测到失败的map或reduce任务;
    并让正常的机器重新执行这些失败的任务;
    因为各个任务之间彼此独立;
    任务的执行顺序是无关紧要的;


    MapReduce计算流程





    MapReduce运行模型


    Map函数——对一部分原始数据进行指定的操作。每个Map操作都针对不同的原始数据,因此Map与Map之间是互相独立的,这使得它们可以充分并行化。
    Reduce操作——对每个Map所产生的一部分中间结果进行合并操作,每个Reduce所处理的Map中间结果是互不交叉的,所有Reduce产生的最终结果经过简单连接就形成了完整的结果集



    数据分布存储,带来计算上的并行化:



    MapReduce操作执行流程图




    展开全文
  • 并行计算是提高处理速度最有效的技术之一,图像并行处理技术为提高图像处理效率提供了广阔的空间。图像并行处理包括并行算法和多处理器并行硬件系统,图像处理并行算法的执行效率依赖于多处理器系统的硬件结构。通常...
  • 基于并行计算的数据处理方法研究_周勇.caj
  • 并行传输数据和串行传输数据 计算机系统中的并行处理数据传输模式 (Parallel Processing and Data Transfer Modes in a Computer System) Instead of processing each instruction sequentially, a parallel ...
  • 数据并行(Data Parallelism)

    千次阅读 2014-05-14 11:10:59
    数据并行,不同的数据输入以并行方式运行同一个函数,它把一个任务分解成不连续的单元,因此,可以在单独的线程上并行处理,保证这个任务可以在可用的处理之间进行分配。 通常是处理数据集合,这种方法利用了集合中...
  • 基于Spring Batch的大数据并行处理 基于Spring Batch的大数据并行处理
  • Python 多CPU并行处理数据

    千次阅读 2017-11-30 21:23:40
    最近遇到结巴分词文本,耗时比较久,于是想到多进程来提升数据处理的效率。  基础代码如下:  import os  import multiprocessing  # worker function  def worker(sign, lock):  lock....
  • 《深入理解大数据:大数据处理与编程实践》在总结多年来MapReduce并行处理技术课程教学经验和成果的基础上,与业界著名企业Intel公司的大数据技术和产品开发团队和资深工程师联合,以学术界的教学成果与业界高水平...
  • java8——并行数据处理与性能

    千次阅读 2018-03-06 11:09:41
    前言在Java7之前,并行处理数据集合非常麻烦。第一,你得明确地把包含数据数据结构分若干子部分;第二,你要给每个字部分分配一个独立的线程。第三,你需要在恰当的时候对它们进行同步来避免不希望出现的竞争条件...
  • 写在开头:你完全可以按照我的模板实现 python并行处理数据,只有7个步骤 背景:已知数据集中包含5500张图片,每一张图片都需要进行图像处理,使用单线程耗费时间大约45min。因此,单线程是不可能的,这辈子都不...
  • Pipeline并行处理模型

    千次阅读 2019-09-03 23:21:07
    但是尽管说并行处理效率确实会比较高,但是它在处理拥有数据结果依赖关系的逻辑时,需要额外的同步管控。例如我的输出怎么临时被存放,然后被下游程序收到处理等等。倘若我们设计的并行处理程序能很好地解...
  • 数据处理并行计算

    万次阅读 2017-05-04 08:06:30
    数据处理并行计算随着对地观测技术的发展,获取到的地理数据越来越精细,而数据量也越来越大,地理数据数据处理与分析的时间耗费就越大。因此,传统的数据处理技术和串行计算技术难以满足高精细地理大数据处理的...
  • Google云计算原理-并行数据处理模型MapReduce中文PPT
  • Python并行处理

    万次阅读 2017-11-02 14:37:36
    原文:Parallel Processing in Python 作者:Frank Hofmann 翻译:Diwei 简介当你在机器上启动某个程序时,它只是在自己的“bubble”...例如,这个所谓的进程环境包括该进程使用的内存页,处理该进程打开的文件,用
  • Math works, nvidiaMatlab2011a的解决方案陈炜Matlab2011 在gpu上的应用华平2007 Tesla宣布gpu有快速的浮点处理能力第一代的x86没有浮点处理单元,8087已经成为业界主流的架构512个核,非常适合做并行的运算真实的...
  • 物联网-物联网智能数据处理技术

    万次阅读 2019-01-20 11:53:12
    物联网数据处理技术的基本概念 物联网数据的特点 海量 动态 多态 关联 从无线传感器网络TinyDB数据库结构中可以清晰地看到物联网数据“海量、动态、多态、关联”的特点 物联网中的数据、信息与知识 ...
  • 深度学习进行分布式训练(模型并行和数据并行优缺点):https://blog.csdn.net/qq_29462849/article/details/81185126
  • 重点讨论了如何实现并行计算,分析了并行平台的数据传输速率,并行加密吞吐率,及平台性能。经实验表明,在并行上实现的多核并行加密方式相比单核串行加密有显著的加速效果,且随着数据量的增大效果逐渐明显。本地...
  • 模型并行( **model parallelism** ):分布式系统中的不同机器... - 数据并行( **data parallelism** ):不同的机器有同一个模型的多个副本,每个机器分配到不同的数据,然后将所有机器的计算结果按照某种方式合并。
  • 欢迎转载,转载请注明:本文出自Bin的专栏blog....Jeff Dean 在演讲中提到,当前的做法是:解决方案 = 机器学习(算法)+ 数据 + 计算力未来有没有可能变为:解决方案 = 数据 + 100 倍的计算力?由此可见,谷歌似乎...
  • 大数据并行处理技术

    2020-04-03 10:11:08
    Kafka是一种高吞吐量的分布式发布订阅消息系统,它可以处理消费者在网站中的所有动作流数据。 Hbase 可用作hadoop数据库,提供分布式可伸缩大型数据存储。用户能随机、实时读写数据。存储十亿行 x 百...
  • ArcGIS Desktop 工具的并行处理

    千次阅读 2015-01-12 11:37:17
    开始下面正文之前,先说一个旧闻,ArcGIS Desktop 10.1 SP1 之后的版本中, 出现了一个不明觉厉的 新特性 —— 并行处理(Parallel Processing)。 现在机器硬件越来越优,多核CPU的机器比比皆是,ArcGIS Desktop...
  • 并行数据挖掘研究

    2013-12-15 23:06:07
    并行数据挖掘自算法的一些探讨,对数据挖掘研究有一些帮助。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 446,272
精华内容 178,508
关键字:

数据并行处理