Spark-RDD Lineage

Spark容错机制,Lineage,Checkpoint Spark容错机制,Lineage,CheckpointLineage机制Checkpoint机制 一般来说,分布式数据集的容错性有两种方式:数据检查点和记录数据的更新。 面向大树据处理检查点机制的代价更高,需要通过数据中心的网络连接在不同的机器之间复制数据,而网络的带宽往往比内存的带宽低的多,并且需要消耗大量的存储资源。因此spark选择了记录数据的更新,但是记录的太细也会消耗大量的资源。因此,... 阅读详情

Spark RDD详解(血统关系)

RDD的概念

Spark计算中一个重要的概念就是可以跨越多个节点的可伸缩分布式数据集 RDD(resilient distributeddataset) Spark的内存计算的核心就是RDD的并行计算。RDD可以理解是一个弹性的,分布式、不可变的、带有分区的数据集合,所谓的Spark的批处理,实际上就是正对RDD的集合操作。

  • 弹性:一个数据集如果很大你可以设置它的并行度,小的数据集你也可以一台机器处理一个。
  • 分布式:指的是spark可以将一个计算拆分为多个阶段,每个阶段都有自己的并行度(这叫做集群)
  • 不可变:计算的RDD的都是只读的,计算完生成新的RDD
  • 带有分区:分区的目的就是为了并行计算,每个机器节点计算的都是局部的数据

RDD有以下特点

  • 任意一个RDD都包含分区数(决定程序某个阶段计算并行度)
  • RDD所谓的分布式计算是在分区内部计算的
  • 因为RDD是只读的,RDD之间的变换存着依赖关系(宽依赖、窄依赖)
  • 针对于k-v类型的RDD,一般可以指定分区策略(一般系统提供)
  • 针对于存储在HDFS上的文件,系统可以计算最优位置,计算每个切片。

在这里插入图片描述
通过上诉的代码中不难发现,Spark的整个任务的计算无外乎围绕RDD的三种类型操作RDD创建、RDD转换、RDD Action.通常习惯性的将flatMap/map/reduceByKey称为RDD的转换算子,collect触发任务执行,因此被人们称为动作算子。在Spark中所有的Transform算子都是lazy执行的,只有在Action算子的时候,Spark才会真正的运行任务,也就是说只有遇到Action算子的时候,SparkContext才会对任务做DAG状态拆分,系统才会计算每个状态下任务的TaskSet,继而TaskSchedule才会将任务提交给Executors执行。现将以上字符统计计算流程描述如下:
在这里插入图片描述
textFile(“路径”,分区数) -> flatMap -> map -> reduceByKey -> sortBy在这些转换中其中flatMap/map、reduceByKey、sotBy都是转换算子,所有的转换算子都是Lazy执行的。程序在遇到collect(Action 算子)系统会触发job执行。Spark底层会按照RDD的依赖关系将整个计算拆分成若干个阶段,我们通常将RDD的依赖关系称为RDD的血统-lineage。血统的依赖通常包含:宽依赖、窄依赖

RDD容错

在理解DAGSchedule如何做状态划分的前提是需要大家了解一个专业术语lineage通常被人们称为RDD的血统
Spark的计算本质就是对RDD做各种转换,因为RDD是一个不可变只读的集合,因此每次的转换都需要上一次的RDD作为本次转换的输入,因此RDD的lineage描述的是RDD间的相互依赖关系。为了保证RDD中数据的健壮性,RDD数据集通过所谓的血统关系(Lineage)记住了它是如何从其它RDD中演变过来的。Spark将RDD之间的关系归类为宽依赖和窄依赖。Spark会根据Lineage存储的RDD的依赖关系对RDD计算做故障容错,目前Saprk的容错策略更具RDD依赖关系重新计算、对RDD做Cache、对RDD做Checkpoint手段完成RDD计算的故障容错。

宽窄依赖

RDD在Lineage依赖方面分为两种Narrow Dependencies与Wide Dependencies用来解决数据容错的高效性。
窄依赖:是指RDD的每一个分区最多被一个子RDD的分区所用。(独生子女)
宽依赖:是指父RDD的一个分区对应一个子RDD的多个分区。

在这里插入图片描述

  • 对于Wide Dependencies这种计算的输入和输出在不同的节点上,一般需要夸节点做Shuffle,因此如果是RDD在做宽依赖恢复的时候需要多个节点重新计算成本较高。
  • 相对于Narrow Dependencies RDD间的计算是在同一个Task当中实现的是线程内部的的计算,因此在RDD分区数据丢失的的时候,也非常容易恢复。

Stage划分(手撕源码)

在分析SparkStage的状态划分之前我们要先了解Spark的计算流程,具体的流程大概如下图
在这里插入图片描述
具体的Spark和MapReduce的区别我们会在下一篇博客中提及。

Spark任务阶段的划分是按照RDD的lineage关系逆向生成的这么一个过程,Spark任务提交的流程大致如下图所示:
在这里插入图片描述
1.首先动作算子才会触发runJob 例如collect

  def collect(): Array[T] = withScope {
    val results = sc.runJob(this, (iter: Iterator[T]) => iter.toArray)
    Array.concat(results: _*)
  }

2.dagScheduler.runJob

  def runJob[T, U: ClassTag](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      partitions: Seq[Int],
      resultHandler: (Int, U) => Unit): Unit = {
    if (stopped.get()) {
      throw new IllegalStateException("SparkContext has been shutdown")
    }
    val callSite = getCallSite
    val cleanedFunc = clean(func)
    logInfo("Starting job: " + callSite.shortForm)
    if (conf.getBoolean("spark.logLineage", false)) {
      logInfo("RDD's recursive dependencies:\n" + rdd.toDebugString)
    }
    dagScheduler.runJob(rdd, cleanedFunc, partitions, callSite, resultHandler, localProperties.get)
    progressBar.foreach(_.finishAll())
    rdd.doCheckpoint()
  }

3.runJob方法里面里面有一个submit Job

def runJob[T, U](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      partitions: Seq[Int],
      callSite: CallSite,
      resultHandler: (Int, U) => Unit,
      properties: Properties): Unit = {
    val start = System.nanoTime
    //submitJob方法
    val waiter = submitJob(rdd, func, partitions, callSite, resultHandler, properties)
    ThreadUtils.awaitReady(waiter.completionFuture, Duration.Inf)
    waiter.completionFuture.value.get match {
      case scala.util.Success(_) =>
        logInfo("Job %d finished: %s, took %f s".format
          (waiter.jobId, callSite.shortForm, (System.nanoTime - start) / 1e9))
      case scala.util.Failure(exception) =>
        logInfo("Job %d failed: %s, took %f s".format
          (waiter.jobId, callSite.shortForm, (System.nanoTime - start) / 1e9))
        // SPARK-8644: Include user stack trace in exceptions coming from DAGScheduler.
        val callerStackTrace = Thread.currentThread().getStackTrace.tail
        exception.setStackTrace(exception.getStackTrace ++ callerStackTrace)
        throw exception
    }
  }

4.submitJob方法会将任务封装成jobsubmitter 提交到eventProcessLoop队列中

def runApproximateJob[T, U, R](
      rdd: RDD[T],
      func: (TaskContext, Iterator[T]) => U,
      evaluator: ApproximateEvaluator[U, R],
      callSite: CallSite,
      timeout: Long,
      properties: Properties): PartialResult[R] = {
    val listener = new ApproximateActionListener(rdd, func, evaluator, timeout)
    val func2 = func.asInstanceOf[(TaskContext, Iterator[_]) => _]
    val partitions = (0 until rdd.partitions.length).toArray
    val jobId = nextJobId.getAndIncrement()
    eventProcessLoop.post(JobSubmitted(
      jobId, rdd, func2, partitions, callSite, listener, SerializationUtils.clone(properties)))
    listener.awaitResult()    // Will throw an exception if the job fails
  }

这里还有很早重要的一点 为什么我eventProcessLoop.post()调用的是handleJobSubmitted
(1)

//首先你的eventProcessLoop 这个对象是由 DAGSchedulerEventProcessLoop生成的
 private[spark] val eventProcessLoop = new DAGSchedulerEventProcessLoop(this)
  taskScheduler.setDAGScheduler(this)

(2)进入DAGSchedulerEventProcessLoop类中看一眼

//然后你发现这个DAGSchedulerEventProcessLoop 对象 又继承了EventLoop 这个对像
private[scheduler] class DAGSchedulerEventProcessLoop(dagScheduler: DAGScheduler)
  extends EventLoop[DAGSchedulerEvent]("dag-scheduler-event-loop") with Logging {

  private[this] val timer = dagScheduler.metricsSource.messageProcessingTimer

  /**
   * The main event loop of the DAG scheduler.
   */
  override def onReceive(event: DAGSchedulerEvent): Unit = {
    val timerContext = timer.time()
    try {
    //看到这里我们好像已经明白怎么回事了 一旦我们调用onReceive方法就会调用下面的doOnReceive
      doOnReceive(event)
    } finally {
      timerContext.stop()
    }
  }
	//然后这里就会做模式匹配 如果你传进来的是一个JobSubmitted 就会调用handleJobSubmitted
  private def doOnReceive(event: DAGSchedulerEvent): Unit = event match {
    case JobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties) =>
      dagScheduler.handleJobSubmitted(jobId, rdd, func, partitions, callSite, listener, properties)

    case MapStageSubmitted(jobId, dependency, callSite, listener, properties) =>
      dagScheduler.handleMapStageSubmitted(jobId, dependency, callSite, listener, properties)

    case StageCancelled(stageId, reason) =>
      dagScheduler.handleStageCancellation(stageId, reason)

    case JobCancelled(jobId, reason) =>
      dagScheduler.handleJobCancellation(jobId, reason)

    case JobGroupCancelled(groupId) =>
      dagScheduler.handleJobGroupCancelled(groupId)

    case AllJobsCancelled =>
      dagScheduler.doCancelAllJobs()

    case ExecutorAdded(execId, host) =>
      dagScheduler.handleExecutorAdded(execId, host)

    case ExecutorLost(execId, reason) =>
      val workerLost = reason match {
        case SlaveLost(_, true) => true
        case _ => false
      }
      dagScheduler.handleExecutorLost(execId, workerLost)

    case WorkerRemoved(workerId, host, message) =>
      dagScheduler.handleWorkerRemoved(workerId, host, message)

    case BeginEvent(task, taskInfo) =>
      dagScheduler.handleBeginEvent(task, taskInfo)

    case SpeculativeTaskSubmitted(task) =>
      dagScheduler.handleSpeculativeTaskSubmitted(task)

    case GettingResultEvent(taskInfo) =>
      dagScheduler.handleGetTaskResult(taskInfo)

    case completion: CompletionEvent =>
      dagScheduler.handleTaskCompletion(completion)

    case TaskSetFailed(taskSet, reason, exception) =>
      dagScheduler.handleTaskSetFailed(taskSet, reason, exception)

    case ResubmitFailedStages =>
      dagScheduler.resubmitFailedStages()
  }

(3) 我们这个时候回头去看EventLoop这个对象 这个对象里我们主要看俩方面


private[spark] abstract class EventLoop[E](name: String) extends Logging {
	//这里是个阻塞队列
  private val eventQueue: BlockingQueue[E] = new LinkedBlockingDeque[E]()

  private val stopped = new AtomicBoolean(false)

  // Exposed for testing.
  //这路在不停的post我们线程在take
  private[spark] val eventThread = new Thread(name) {
    setDaemon(true)
	
    override def run(): Unit = {
      try {
        while (!stopped.get) {
        //第一方面对于eventQueue这个队列的操作 一致在take 同时在调onReceiver方法
          val event = eventQueue.take()
          try {
            onReceive(event)
          } catch {
            case NonFatal(e) =>
              try {
                onError(e)
              } catch {
                case NonFatal(e) => logError("Unexpected error in " + name, e)
              }
          }
        }
      } catch {
        case ie: InterruptedException => // exit even if eventQueue is not empty
        case NonFatal(e) => logError("Unexpected error in " + name, e)
      }
    }

 /**
   * Put the event into the event queue. The event thread will process it later.
   */
   //第二个方法就是这个 也就是一开始的 eventProcessLoop.post(BeginEvent(task, taskInfo)) 
  def post(event: E): Unit = {
    eventQueue.put(event)
  }

  }

(4)这个时候我们的问题好像明朗了 再回头看eventProcessLoop.post(BeginEvent(task, taskInfo)) 明白了吧

  eventProcessLoop.post()

5.DAGSchedule收到队列的事件之后,调用handleJobSubmiited开始处理job

private[scheduler] def handleJobSubmitted(jobId: Int,
      finalRDD: RDD[_],
      func: (TaskContext, Iterator[_]) => _,
      partitions: Array[Int],
      callSite: CallSite,
      listener: JobListener,
      properties: Properties) {
    var finalStage: ResultStage = null
    try {
      // New stage creation may throw an exception if, for example, jobs are run on a
      // HadoopRDD whose underlying HDFS files have been deleted.
      finalStage = createResultStage(finalRDD, func, partitions, jobId, callSite)
    } catch {
      case e: BarrierJobSlotsNumberCheckFailed =>
        logWarning(s"The job $jobId requires to run a barrier stage that requires more slots " +
          "than the total number of slots in the cluster currently.")
        // If jobId doesn't exist in the map, Scala coverts its value null to 0: Int automatically.
        val numCheckFailures = barrierJobIdToNumTasksCheckFailures.compute(jobId,
          new BiFunction[Int, Int, Int] {
            override def apply(key: Int, value: Int): Int = value + 1
          })
        if (numCheckFailures <= maxFailureNumTasksCheck) {
          messageScheduler.schedule(
            new Runnable {
              override def run(): Unit = eventProcessLoop.post(JobSubmitted(jobId, finalRDD, func,
                partitions, callSite, listener, properties))
            },
            timeIntervalNumTasksCheck,
            TimeUnit.SECONDS
          )
          return
        } else {
          // Job failed, clear internal data.
          barrierJobIdToNumTasksCheckFailures.remove(jobId)
          listener.jobFailed(e)
          return
        }

      case e: Exception =>
        logWarning("Creating new stage failed due to exception - job: " + jobId, e)
        listener.jobFailed(e)
        return
    }
    // Job submitted, clear internal data.
    barrierJobIdToNumTasksCheckFailures.remove(jobId)

    val job = new ActiveJob(jobId, finalStage, callSite, listener, properties)
    clearCacheLocs()
    logInfo("Got job %s (%s) with %d output partitions".format(
      job.jobId, callSite.shortForm, partitions.length))
    logInfo("Final stage: " + finalStage + " (" + finalStage.name + ")")
    logInfo("Parents of final stage: " + finalStage.parents)
    logInfo("Missing parents: " + getMissingParentStages(finalStage))

    val jobSubmissionTime = clock.getTimeMillis()
    jobIdToActiveJob(jobId) = job
    activeJobs += job
    finalStage.setActiveJob(job)
    val stageIds = jobIdToStageIds(jobId).toArray
    val stageInfos = stageIds.flatMap(id => stageIdToStage.get(id).map(_.latestInfo))
    listenerBus.post(
      SparkListenerJobStart(job.jobId, jobSubmissionTime, stageInfos, properties))
      //优先处理最后一个stage 
    submitStage(finalStage)
  }

6.这里是最重要的一个方法【submitStage】

private def submitStage(stage: Stage) {
    val jobId = activeJobForStage(stage)
    if (jobId.isDefined) {
      logDebug("submitStage(" + stage + ")")
      if (!waitingStages(stage) && !runningStages(stage) && !failedStages(stage)) {
      //这里是先去查找所有我父类的stage 方法就是下面的getMissingParentStages方法 就是找宽依赖
        val missing = getMissingParentStages(stage).sortBy(_.id)
        logDebug("missing: " + missing)
        //如果不存在父stage 就执行当前stage下的task
        if (missing.isEmpty) {
          logInfo("Submitting " + stage + " (" + stage.rdd + "), which has no missing parents")
          //调用TaskSchedule#submit(TaskSet)任务调度
          submitMissingTasks(stage, jobId.get)
        } else {
          for (parent <- missing) {
          //如果存在父stage 就递归调用这个方法继续寻找父stage
            submitStage(parent)
          }
          waitingStages += stage
        }
      }
    } else {
      abortStage(stage, "No active job for stage " + stage.id, None)
    }
  }
 private def getMissingParentStages(stage: Stage): List[Stage] = {
 	//定义俩个栈
    val missing = new HashSet[Stage]
    val visited = new HashSet[RDD[_]]
    // We are manually maintaining a stack here to prevent StackOverflowError
    // caused by recursively visiting
    val waitingForVisit = new ArrayStack[RDD[_]]
    def visit(rdd: RDD[_]) {
      if (!visited(rdd)) {
        visited += rdd
        val rddHasUncachedPartitions = getCacheLocs(rdd).contains(Nil)
        if (rddHasUncachedPartitions) {
          for (dep <- rdd.dependencies) {
            dep match {
              case shufDep: ShuffleDependency[_, _, _] =>
              //注意处理最后一个resultstage之外 其余的都叫做shuffleMapStage
              //宽依赖就添加一个stage
                val mapStage = getOrCreateShuffleMapStage(shufDep, stage.firstJobId)
                if (!mapStage.isAvailable) {
                  missing += mapStage
                }
                //窄依赖放在visit父RDD栈中
              case narrowDep: NarrowDependency[_] =>
                waitingForVisit.push(narrowDep.rdd)
            }
          }
        }
      }
    }
    waitingForVisit.push(stage.rdd)
    while (waitingForVisit.nonEmpty) {
      visit(waitingForVisit.pop())
    }
    missing.toList
  }

注
在这里插入图片描述
7.这个时候我们跳到上一步的 submitMissingTasks(stage, jobId.get)任务调度这一行代码中

//找到submitMissingTask之后发现这里有个try块 明显将要提交的task分为了俩块 
//一个是ShuffleMapTask 一个是ResultTask
val tasks: Seq[Task[_]] = try {
      val serializedTaskMetrics = closureSerializer.serialize(stage.latestInfo.taskMetrics).array()
      stage match {
        case stage: ShuffleMapStage =>
          stage.pendingPartitions.clear()
          partitionsToCompute.map { id =>
            val locs = taskIdToLocations(id)
            val part = partitions(id)
            stage.pendingPartitions += id
            new ShuffleMapTask(stage.id, stage.latestInfo.attemptNumber,
              taskBinary, part, locs, properties, serializedTaskMetrics, Option(jobId),
              Option(sc.applicationId), sc.applicationAttemptId, stage.rdd.isBarrier())
          }

        case stage: ResultStage =>
          partitionsToCompute.map { id =>
            val p: Int = stage.partitions(id)
            val part = partitions(p)
            val locs = taskIdToLocations(id)
            new ResultTask(stage.id, stage.latestInfo.attemptNumber,
              taskBinary, part, locs, id, properties, serializedTaskMetrics,
              Option(jobId), Option(sc.applicationId), sc.applicationAttemptId,
              stage.rdd.isBarrier())
          }
      }
    } catch {
      case NonFatal(e) =>
        abortStage(stage, s"Task creation failed: $e\n${Utils.exceptionString(e)}", Some(e))
        runningStages -= stage
        return
    }
       if (tasks.size > 0) {
         logInfo(s"Submitting ${tasks.size} missing tasks from $stage (${stage.rdd}) (first 15 " +
         s"tasks are for partitions ${tasks.take(15).map(_.partitionId)})")
         //这不就回到一开始的计算流程图中taskScheduler调用submitTask方法将TaskSet提交 
          taskScheduler.submitTasks(new TaskSet(
        tasks.toArray, stage.id, stage.latestInfo.attemptNumber, jobId, properties))
    } 

总结

通过以上源码分析,可以得出Spark所谓宽窄依赖事实上指的是ShuffleDependency或者是NarrowDependency如果是ShuffleDependency系统会生成一个ShuffeMapStage,如果是NarrowDependency则忽略,归为当前Stage。当系统回推到起始RDD的时候因为发现当前RDD或者ShuffleMapStage没有父Stage的时候,当前系统会将当前State下的Task封装成ShuffleMapTask(如果是ResultStage就是ResultTask),当前Task的数目等于当前state分区的分区数。然后将Task封装成TaskSet通过调用taskScheduler.submitTasks将任务提交给集群。

RDD缓存

缓存是一种RDD计算容错的一种手段,程序在RDD数据丢失的时候,可以通过缓存快速计算当前RDD的值,而不需要反推出所有的RDD重新计算,因此Spark在需要对某个RDD多次使用的时候,为了提高程序的执行效率用户可以考虑使用RDD的cache。如下测试:

	val conf = new SparkConf()
		.setAppName("word-count")
		.setMaster("local[2]")
	val sc = new SparkContext(conf)
	val value: RDD[String] = sc.textFile("file:///D:/demo/words/")
	   .cache()
	value.count()
	
	var begin=System.currentTimeMillis()
	value.count()
	var end=System.currentTimeMillis()
	println("耗时:"+ (end-begin))//耗时:253
	
	//失效缓存
	value.unpersist()
	begin=System.currentTimeMillis()
	value.count()
	end=System.currentTimeMillis()
	println("不使用缓存耗时:"+ (end-begin))//2029
	sc.stop()

除了调用cache之外,Spark提供了更细粒度的RDD缓存方案,用户可以根据集群的内存状态选择合适的缓存策略。用户可以使用persist方法指定缓存级别。缓存级别有很多:

xxRDD.persist(StorageLevel.MEMORY_AND_DISK_SER_2) / /推荐使用这个

MEMORY_ONLY:表示数据完全不经过序列化存储在内存中,效率高,但是有可能导致内存溢出.

MEMORY_ONLY_SER和MEMORY_ONLY一样,只不过需要对RDD的数据做序列化,牺牲CPU节省内存,同样会导致内存溢出可能。

其中_2表示缓存结果有备份

Check Point 机制

除了使用缓存机制可以有效的保证RDD的故障恢复,但是如果缓存失效还是会在导致系统重新计算RDD的结果,所以对于一些RDD的lineage较长的场景,计算比较耗时,用户可以尝试使用checkpoint机制存储RDD的计算结果,该种机制和缓存最大的不同在于,使用checkpoint之后被checkpoint的RDD数据直接持久化在文件系统中,一般推荐将结果写在hdfs中,这种checpoint并不会自动清空。注意checkpoint在计算的过程中先是对RDD做mark,在任务执行结束后,再对mark的RDD实行checkpoint,也就是要重新计算被Mark之后的rdd的依赖和结果,因此为了避免Mark RDD重复计算,推荐使用策略

	val conf = new SparkConf().setMaster("yarn").setAppName("wordcount")
	val sc = new SparkContext(conf)
	sc.setCheckpointDir("hdfs:///checkpoints")
	
	val lineRDD: RDD[String] = sc.textFile("hdfs:///words/t_word.txt")
	
	val cacheRdd = lineRDD.flatMap(line => line.split(" "))
	.map(word => (word, 1))
	.groupByKey()
	.map(tuple => (tuple._1, tuple._2.sum))
	.sortBy(tuple => tuple._2, false, 1)
	.cache()
	cacheRdd.checkpoint()
	
	cacheRdd.collect().foreach(tuple=>println(tuple._1+"->"+tuple._2))
	cacheRdd.unpersist()
	//3.关闭sc
	sc.stop()

spark Streaming中 是这样写程序一旦运行要改就要先删除checkpoint

    val conf = new SparkConf().setAppName("userlocation").setMaster("local[5]")
    var checkpointDir="file:///D:/checkpoints"
    var ssc=StreamingContext.getOrCreate(checkpointDir,()=>{
Spark Lineage(血统) 利用内存加快数据加载,在众多的其它的In-Memory类数据库或Cache类系统中也有实现,Spark的主要区别在于它处理分布式运算环境下的数据容错性(节点实效/数据丢失)问题时采用的方案。为了保证RDD中数据的鲁棒性,RDD数据集通过所谓的血统关系(Lineage)记住了它是如何从其它RDD中演变过来的。相比其它系统的细颗粒度的内存数据更新级别的备份或者LOG机制,RDD的Lineage记录的是 阅读详情

相关推荐

GLMM(广义线性混合模型)原理以及分析步骤

广义线性混合模型(GLMM)是生态与进化研究中处理非正态数据的定制化工具,能同时分析固定效应和随机效应。它通过链接函数连接响应变量与预测因子,支持二项分布、泊松分布等非正态数据。研究流程包括:明确分析目标(固定效应影响与随机效应方差)、选择合适变量与分布、数据验证、参数估算(需根据模型复杂度选择PQL、拉普拉斯近似等方法)及模型优化(检验过离散与残差,通过信息准则或假设检验筛选最优模型)。GLMM能有效解决传统方法无法处理的"伪重复"和推广性问题,为复杂生物数据提供可靠分析框架。

wewil_lwin的博客 5005

spark2.0原理分析--RDD血缘(RDD Lineage)

本文介绍了RDD的血缘基本概念和形成。血缘是由于RDD的转换操作形成的多个RDD的依赖关系。RDD的血缘不依赖数据的计算。每个RDD都有一个依赖的父RDD的引用的列表,通过这个列表来找到依赖的父RDD,多个RDD的依赖形成了一个DAG图(有向无环图)。这就是RDD的血缘(RDD Lineage)。

zg_hover的专栏 6280

Teams会议翻译对比测试:Copilot同传 vs 人工翻译,结果出乎意料

本文通过对比测试Microsoft 365 Copilot的实时翻译与专业人工翻译在Teams会议中的表现,揭示了AI同传技术在准确率、响应速度和多语言切换方面的优势与局限。实验数据显示,Copilot在常规商务场景下接近人工翻译水平,且成本效益显著,但在专业术语和文化特定表达上仍需人工辅助。

weixin_29054195的博客 224

RDD依赖关系Lineage_大数据培训

将创建RDD的一系列Lineage(血统)记录下来,以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为,当该RDD的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。注意:RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。(3)查看“wordAndOne”的Lineage。(6)查看“wordAndCount”的依赖类型。(5)查看“wordAndOne”的依赖类型。

zjjcchina的博客 313

SAP Script表单开发中ABAP preform方法的实战应用与调试技巧

本文深入探讨了在SAP Script表单开发中调用ABAP程序(preform方法)的实战应用与调试技巧。通过一个获取供应商版本名称的实例,详细讲解了如何在SE71中嵌入PERFORM指令、编写ABAP子程序进行数据查询与处理,并重点介绍了使用SAP Script Debugger进行高效调试的方法,帮助开发者灵活扩展表单功能,实现复杂业务逻辑。

o0p1q2r3的博客 554

钉钉开发(三)——Java推送钉钉待办任务

之前一篇博文中,讲解了如何推送钉钉群消息,感兴趣的可以点击查看。 钉钉开发(一)——Java给钉钉群推送消息

Monten_Cristo的博客 6412

Cloudera系列(5)使用RDD转换数据

一、编写和传递转换函数 二、转换执行 三、RDD和DataFrame之间的转换 四、基本要点 五、实践练习:使用RDD转换数据 1、探索Loudacre Web日志文件 1、在本节中,您将使用$DEVDATA/weblogs中的数据。查看目录中的.log文件。注意这几行的格式: 2、将“weblogs”目录从本地文件系统复制到HDFS目录“/devsh_loudacre”。 $ hdfs dfs -put $DEVDATA/weblogs /devsh_loudacre/ 3、在Spark中,从HDF

boranyueshijie的博客 2467

ISCC练习题MISC

解题技巧:看最后括号应该是IceCTF,先用了一键解码啥也没有啊,不对不对!好像是字符频率统计,转换网站:http://quipqiup.com/有人给你发了一串信息,你能解开吗?

m0_62737381的博客 1121

Spark入门-Dependencies、Lineage and Stage

Spark中比较重要的一块就是血缘关系和阶段划分,虽说并不能像累加器或者广播变量解决特定的需求,但对于理解Spark计算的任务执行调度有很大的帮助。 Lineage(血缘关系) RDD 只支持粗粒度转换,即在大量记录上执行的单个操作。将创建 RDD 的一系列 Lineage (血统)记录下来,以便恢复丢失的分区。RDD 的 Lineage 会记录 RDD 的元数据信息和转换行为,当该 RDD 的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。 RDD不保存数据,在没有缓存和检查点的情况

汪巡的博客 438

GB28181 —— 1、Ubuntu20.04下使用ZLMediaKit+WVP搭建GB28181流媒体监控平台(连接带云台摄像机)

GB28181 —— Ubuntu20.04下使用ZLMediaKit+WVP搭建GB28181流媒体监控平台

5464

Xilinx FPGA资源解析与使用系列——Transceiver(六)关键时钟梳理之TXOUTCLK和RXOUTCLK

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 Xilinx FPGA资源解析与使用系列——Transceiver(六)transceiver内部关键时钟梳理之TXOUTCLK和RXOUTCLK前言TXOUTCLKRXOUTCLK 前言 前面我们已经研读了 transceiver的参考时钟 和复位的相关内容。 但是随着内容的深入,越来越多的信号出现在我的面前。 例如 TXOUTCLK、TXUSERCLK、TXUSERCLK2 RXOUTCLK、RXUSERCLK、RXUSERCLK2

gzy0506的博客 8090

Spark Lineage(血统)

Lineage简介 宽依赖 Narrow Dependencies 窄依赖 Wide Dependencies 容错原理

一个人的编程之路 6864

ESD防护设计宝典(二十三):ESD与EOS失效差异分析

ESD和EOS是电子制造业面临的两大挑战,随着电子产品向更高集成度、更低工作电压和更高工作频率发展,这一问题将更加突出。根据美国军方上世纪八十年代与可靠性分析中心(RAC)共同建立的现场失效返回程序(FFRP)统计数据,产品现场返回中EOS占比高达46%,而ESD仅占6%,另有6%的案例难以区分是EOS还是ESD。

m0_56451176的博客 322

Spark RDD详解 —— RDD特性、lineage、缓存、checkpoint、依赖关系

RDD(Resilient Distributed Datasets)弹性的分布式数据集,又称Spark core,它代表一个只读的、不可变、可分区,里面的元素可分布式并行计算的数据集。RDD是一个很抽象的概念,不易于理解,但是要想学好Spark,必须要掌握RDD,熟悉它的编程模型,这是学习Spark其他组件的基础。提到大数据必提分布式,而在大规模的分布式集群中,任何一台服务器随时都有可能出现故障,如果一个task任务所在的服务器出现故障,必然导致这个task执行失败。

智海观潮的博客 1104

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Spark2.2-persist checkpoint lineage解析

源码版本: 2.2 如有错误请指正 一、背景     Spark中每一个RDD都记录它的血缘lineage,根据lineage,我们可以实现容错机制和数据重用。     相比其他系统的细颗粒度的内存数据更新级别的备份或者LOG机制,RDD的Lineage记录的是粗颗粒度的特定数据Transformation操作(如filter、map、join等)行为。当这个RDD的部分分

junerli的博客 1222

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Spark两种核心的容错机制:Lineage(血统)和 Checkpointing(检查点)

摘要: Spark 通过 Lineage(血统) 和 Checkpointing(检查点) 两种机制实现容错。Lineage 记录 RDD 的转换逻辑(DAG 图),在节点故障时通过回溯计算重建丢失数据,适用于短依赖链场景。Checkpointing 则将 RDD 数据持久化到可靠存储(如 HDFS),截断冗长的 Lineage 链,尤其适合迭代算法或宽依赖操作,加速故障恢复。两者协同工作:Lineage 默认处理容错,Checkpointing 在关键节点截断依赖链,故障时优先从检查点恢复,未覆盖部分再通

csdn_tom_168的博客 862

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

关于spark RDD trans action算子、lineage、宽窄依赖详解

这篇文章想从spark当初设计时为何提出RDD概念,相对于hadoop,RDD真的能给spark带来何等优势。之前本想开篇是想总体介绍spark,以及环境搭建过程,但个人感觉RDD更为重要铺垫在hadoop中一个独立的计算,例如在一个迭代过程中,除可复制的文件系统(HDFS)外没有提供其他存储的概念,这就导致在网络上进行数据复制而增加了大量的消耗,而对于两个的MapReduce作业之间数据共享只有...

张小丑 2206

spark RDD概念及其算子举例讲解

作为之前对spark RDD可以说是完全不懂的小白,在阅读部分网友的博客的基础上,我从自己理解的角度和方式来记录一下自己学习spark RDD的过程。 目录 一、RDD介绍 1.1RDD是什么 1.2Spark与RDD的关系 1.3为什么会产生RDD 1.4RDD底层实现原理 1.5 RDD的操作 二、通过例子学习spark RDD的操作 2.1 Action函数 ...

anshuai_aw1的博客 2449

Spark整理:RDD容错

RDD提供了一种高度受限的共享内存模型,即RDD是只读的记录分区的集合,只能通过在其他RDD执行确定的转换操作(如map、join和group by)而创建,然而这些限制使得实现容错的开销很低。与分布式共享内存系统需要付出高昂代价的检查点和回滚机制不同,RDD通过Lineage来重建丢失的分区:一个RDD中包含了如何从其他RDD衍生所必需的相关信息,从而不需要检查点操作就可以重构丢失的数据分区。 分布式数据集的容错性有两种方式:即数据检查点和记录数据的更新。我们面向的是大规模数据分析,数据检查点操作成本很高

weixin_38602383的博客 1152

SparkCore之RDD依赖关系

Lineage RDD只支持粗粒度转换,即在大量记录上执行的单个操作。将创建RDD的一系列Lineage(血统)记录下来,以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为,当该RDD的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。 读取一个HDFS文件并将其中内容映射成一个个元组 scala> val wordAndOne = sc....

@小刘同学nice 223

【总结】Spark容错机制

容错方式 容错 指的是一个系统在部分模块出现故障时还能否持续的对外提供服务,一个高可用的系统应该具有很高的容错性;对于一个大的集群系统来说,机器故障、网络异常等都是很常见的,Spark这样的大型分布式计算集群提供了很多的容错机制来提高整个系统的可用性。 一般来说,分布式数据集的容错性有两种方式:数据检查点和记录数据的更新。 面向大规模数据分析,数据检查点操作成本很高,需要通过数据中心的

一寒惊鸿 3万+

Spark整理-名词解释

Spark系列 1,概述 (1)为什么会有Spark?因为传统的并行计算模型无法有效的解决迭代计算(iterative)和交互式计算(interactive);而Spark的使命便是解决这两个问题,这也是他存在的价值和理由。 (2)Spark如何解决迭代计算?其主要实现思想就是RDD,把所有计算的数据保存在分布式的内存中。迭代计算通常情况下都是对同一个数据集做反复的迭代计算,数据在内存中将大大提升IO操作。这也是Spark涉及的核心:内存计算。 (3)Spark如何实现交互式计算?交互式下对查询速度、计算速

weixin_38602383的博客 1584

Spark Core快速入门系列(6) | RDD的依赖关系

  大家好,我是不温卜火,是一名计算机学院大数据专业大二的学生,昵称来源于成语—不温不火,本意是希望自己性情温和。作为一名互联网行业的小白,博主写博客一方面是为了记录自己的学习过程,另一方面是总结自己所犯的错误希望能够帮助到很多和自己一样处于起步阶段的萌新。但由于水平有限,博客中难免会有一些错误出现,有纰漏之处恳请各位大佬不吝赐教!暂时只有csdn这一个平台,博客主页:https://buwenbuhuo.blog.youkuaiyun.com/   此篇为大家带来的是RDD的依赖关系 目录   本次的分享就.

不温卜火 7216

关于spark RDD trans action算子、lineage、宽窄依赖详解

这篇文章想从spark当初设计时为何提出RDD概念,相对于hadoop,RDD真的能给spark带来何等优势。之前本想开篇是想总体介绍spark,以及环境搭建过程,但个人感觉RDD更为重要 铺垫 在hadoop中一个独立的计算,例如在一个迭代过程中,除可复制的文件系统(HDFS)外没有提供其他存储的概念,这就导致在网络上进行数据复制而增加了大量的消耗,而对于两个的MapReduc...

weixin_30507269的博客 120

实用 | RDD依赖关系

一、Lineage RDD只支持粗粒度转换,即在大量记录上执行的单个操作。将创建RDD的一系列Lineage(血统)记录下来,以便恢复丢失的分区。RDD的Lineage会记录RDD的元数据信息和转换行为,当该RDD的部分分区数据丢失时,它可以根据这些信息来重新运算和恢复丢失的数据分区。 (1)读取一个HDFS文件并将其中内容映射成一个个元组 scala> v...

qq_41359684的博客 510
上一篇: SpringCloud-快速上手
下一篇: SpringCloud-Hystrix(断路器)
zax_java
博客等级 码龄8年 62粉丝 23原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值