rdd

RDD 宽窄依赖 RDD之间有一系列的依赖关系, 可分为窄依赖和宽依赖 窄依赖 从 RDD 的 parition 角度来看 父 RRD 的 parition 和 子 RDD 的 parition 之间的关系是一对一的 (或 者是多对一的)。 不会有 shuffle 产生 宽依赖 父 RRD 的 parition 和 子 RDD 的 parition 之间的关系是一对多的 会产生shuffle 理解图 对stage(阶段)划分的影响 DAGSchedular 根据依赖类型切割RDD划分stage, 如果是宽依赖, 就进行切割, 并且递归查找其所有父类RDD 示意图: 来源： https://www.cnblogs.com/ronnieyuan/p/11727747.html

Spark编程-----二次排序和分组取TopN RDD的宽窄依赖 宽依赖：每一个父RDD的Partition中的数据，都可能传输到子RDD的每个Partition中，这种错综复杂的关系，叫宽依赖 宽依赖划分依据：Shuffle 窄依赖：一个RDD对它的父RDD，只有一个一对一的依赖关系，也就是说，RDD的每个Partition，仅仅依赖于一个父RDD的Partition，一对一的关系叫窄依赖 窄依赖划分依据：没有Shuffle Join有一个特殊情况，虽然Join是Shuffle算子，但是也会触发窄依赖 例如： 血缘 父RDD与子RDD直接存在依赖关系，这种依赖关系叫血缘，同时通过血缘关系，可以达到容错的机制（RDD之间的容错） 案例：基站解析案例 根据用户产生日志的信息,在那个基站停留时间最长 19735E1C66.log 这个文件中存储着日志信息 文件组成:手机号,时间戳,基站ID 连接状态(1连接 0断开) lac_info.txt 这个文件中存储基站信息 文件组成 基站ID, 经,纬度 在一定时间范围内,求所用户经过的所有基站所停留时间最长的Top2 思路: 1.获取用户产生的日志信息并切分 2.用户在基站停留的总时长 3.获取基站的基础信息 4.把经纬度的信息join到用户数据中 5.求出用户在某些基站停留的时间top2 案例：统计某时间段学科访问量TopN

Spark任务执行流程 DAGScheduler 和TaskScheduler都在Driver端（开启spark-shell的那一端），main函数创建SparkContext时会使得driver和Master节点建立连接，Master会根据任务所需资源在集群中找符合条件的worker.然后Master对worker进行RPC通信，通知worker启动Executor ，Executor会和Driver 建立连接，随后的工作worker和Master不再有关系。 然后Driver会向Executor提交Task。 1. RDD Objects RDD构建，RDD进行一系列transformation操作后最终遇到Action方法时，DAG图即确定了边界，DAG图形成,然后会将DAG提交给DAGScheduler. DAG(Directed Acyclic Graph)叫做有向无环图，原始的RDD通过一系列的转换就就形成了DAG，根据RDD之间的依赖关系的不同将DAG划分成不同的Stage，对于窄依赖，partition的转换处理在Stage中完成计算。对于宽依赖，由于有Shuffle的存在，只能在parent RDD处理完成后，才能开始接下来的计算，因此宽依赖是划分Stage的依据。 2、DAGScheduler(调度器) 将DAG切分成多个stage,切分依据(宽依赖

I am using HashPartioner but getting an unexpected result. I am using 3 different String as keys, and giving partition parameter as 3, so I expect 3 partitions. val cars = Array("Honda", "Toyota", "Kia") val carnamePrice = sc.parallelize(for { x <- cars y <- Array(100,200,300) } yield (x, y), 8) val rddEachCar = carnamePrice.partitionBy(new HashPartitioner(3)) val mapped = rddEachCar.mapPartitionsWithIndex{ (index, iterator) => { println("Called in Partition -> " + index) val myList = iterator.toList myList.map(x => x + " -> " + index).iterator } } mapped.take(10) The result is below. It gives

Assuming the existence of an RDD of tuples similar to the following: (key1, 1) (key3, 9) (key2, 3) (key1, 4) (key1, 5) (key3, 2) (key2, 7) ... What is the most efficient (and, ideally, distributed) way to compute statistics corresponding to each key? (At the moment, I am looking to calculate standard deviation / variance, in particular.) As I understand it, my options amount to: Use the colStats function in MLLib : This approach has the advantage of easily-adaptable to use other mllib.stat functions later, if other statistical computations are deemed necessary. However, it operates on an RDD

The current Pyspark dataframe has this structure (a list of WrappedArrays for col2): +---+---------------------------------------------------------------------+ |id |col2 | +---+---------------------------------------------------------------------+ |a |[WrappedArray(code2), WrappedArray(code1, code3)] | +---+---------------------------------------------------------------------+ |b |[WrappedArray(code5), WrappedArray(code6, code8)] | +---+---------------------------------------------------------------------+ This is the structure I would like to have (a flattened list for col2): +---+----------

spark 资源调度包 Stage(阶段) 类解析 类注释: /** * A stage is a set of parallel tasks all computing the same function that need to run as part * of a Spark job, where all the tasks have the same shuffle dependencies. * 一个阶段是所有计算相同功能的并行任务集合, 作为spark作业的一部分, 这些任务都有相同的 shuffle 依赖 * * Each DAG of tasks run by the scheduler is split up into stages at the boundaries where * shuffle occurs, and then the DAGScheduler runs these stages in topological order. * 每个由调度器运行的任务的有向无环图在shuffle发生的分界处分化成不同的阶段, 并且这些有向无环图的调度器 * 将以拓扑排序来运行这些 不同阶段的任务 * * Each Stage can either be a shuffle map stage, in which case its tasks' results

I have an RDD of (key,value) elements. The keys are NumPy arrays. NumPy arrays are not hashable, and this causes a problem when I try to do a reduceByKey operation. Is there a way to supply the Spark context with my manual hash function? Or is there any other way around this problem (other than actually hashing the arrays "offline" and passing to Spark just the hashed key)? Here is an example: import numpy as np from pyspark import SparkContext sc = SparkContext() data = np.array([[1,2,3],[4,5,6],[1,2,3],[4,5,6]]) rd = sc.parallelize(data).map(lambda x: (x,np.sum(x))).reduceByKey(lambda x,y: x