13、SparkContext詳細

、SparkContext原則

図1に示すように、図示

二、SparkContextソース

1、TaskSchedulerを作成します

SparkContext.scala ### 

// 作成し、スケジューラで起動する
  プライベート [スパーク] VAR（schedulerBackend、TaskScheduler）= 
    SparkContext.createTaskScheduler（これ、マスター）



// 異なるTaskSchedulerを作成し、異なるコミットモード
 // スタンドアロンモードの
      ケース SPARK_REGEX （sparkUrl）=>
      // TaskSchedulerImpl（）異なるクラスタ（スタンドアロン、糸及びmesos）のタイプ、スケジューリングタスクの底SchedulerBackendの操作によって。
    
     // 彼はまた、ローカルモードで動作するように、によってLocalBackend、そしてtrueに設定のisLocalパラメータを使用することができます。
   
     // このような検査タスクの実行開始、複数のジョブスケジューリングの順序を決定するよう、いくつかの一般的なロジックを処理
    
     // （）メソッドをして）（クライアント最初のアプリケーションのスケジューリング初期化の方法を（）起動し、タスクを送信runTasks方法を設定し、 
        ヴァルを=スケジューラー新新TaskSchedulerImpl（SC）
        のval masterUrls = sparkUrl.split（ " "）.MAP（"スパーク：//" + _）
        ヴァル・バックエンド = 新しいSparkDeploySchedulerBackend（スケジューラ、SC、masterUrls）
        scheduler.initialize（バックエンド）
        （バックエンド、スケジューラ）





### TaskSchedulerImpl.scalaは

  DEF（バックエンド：SchedulerBackend）を初期化{ 
    この .backend = バックエンド
     // 空に仮設定rootPool名を 
    rootPool = 新しいプール（ ""、schedulingMode、0、0 ）
    schedulableBuilder = { 
      schedulingMode一致{ 
        ケースSchedulingMode.FIFO =>
           新しいFIFOSchedulableBuilder（rootPool）
         場合 SchedulingMode.FAIR =>
           新しいFairSchedulableBuilder（rootPool、CONF）
      } 
    } 
    schedulableBuilder.buildPools（）
  }

TaskSchedulerが起動します。

### TaskSchedulerImpl.scalaは

  {）（開始DEF上書き
// 重点是调用了SparkDeploySchedulerBackend类的開始
    ）（backend.startを

    場合（！のisLocal && conf.getBoolean（ "spark.speculation"、偽））{ 
      LOGINFO（「開始投機実行スレッド」）
       インポートsc.env.actorSystem.dispatcher 
      sc.env.actorSystem.scheduler.schedule（SPECULATION_INTERVALミリ秒、
            SPECULATION_INTERVALミリ秒）{ 
        Utils.tryOrExit {checkSpeculatableTasks（）} 
      } 
    } 
  } 





### SparkDeploySchedulerBackend.scala 

  開始DEFオーバーライド（）{ 
    スーパー.start（）

    // 私たちに話をするのエグゼキュータのエンドポイント 
    ヴァルdriverUrl = AkkaUtils.address（
      AkkaUtils.protocol（actorSystem）、
      SparkEnv.driverActorSystemName、
      conf.get（ "spark.driver.host" ）、
      conf.get（「spark.driver。ポート" ）、
      CoarseGrainedSchedulerBackend.ACTOR_NAME）
    ヴァル引数 = SEQ（
       "--driver-URL" 、driverUrl、
       "--executor-ID"、 "{{EXECUTOR_ID}}" 、
       "--hostname"、" {{HOSTNAME} } " "--cores"、 "{{CORES}}" 、
       "--app-ID"、"{{APP_ID}}」 、
      "--worker-URL"、 "{{WORKER_URL}}" ）
    ヴァルextraJavaOpts = sc.conf.getOption（ "spark.executor.extraJavaOptions" ）
      .MAP（Utils.splitCommandString）.getOrElse（Seq.empty）
    ヴァルclassPathEntries = sc.conf.getOption（ "spark.executor.extraClassPath" ）
      .MAP（_。スプリット（java.io.File.pathSeparator）.toSeq）.getOrElse（NIL）
    ヴァルlibraryPathEntries = sc.conf.getOption（ "spark.executor .extraLibraryPath」）
      の.map（_。スプリット（java.io.File.pathSeparator）.toSeq）.getOrElse（無記号）

    // テストする場合、子供に親クラスのパスを公開します。これは、によって処理される
     //-クラスパスを計算する。{cmdと、SH}と子プロセスに必要なすべてのjarが利用できるようになります
     // アセンブリは、「* -provided」プロファイルを有効にして構築されたとき。
    ヴァルtestingClassPath = あれば（sys.props.contains（ "spark.testing" ））{ 
        sys.props（ "のjava.class.path" ）.split（java.io.File.pathSeparator）.toSeq 
      } 他{ 
        無記号
      } / / スケジューラに登録するためのいくつかの必要なコンフィグでスタートエグゼキュータ 
    ヴァルsparkJavaOpts = Utils.sparkJavaOpts（confに、SparkConf.isExecutorStartupConf）
    ヴァルjavaOpts = sparkJavaOpts ++ extraJavaOpts
      

     
    valのコマンド =コマンド（ "org.apache.spark.executor.CoarseGrainedExecutorBackend" 、
      引数、sc.executorEnvs、classpathEntries ++ testingClassPath、libraryPathEntries、javaOpts）
    ヴァルappUIAddress = sc.ui.map（_。appUIAddress）.getOrElse（ "" ）

    // ApplicationDescriptionは非常に重要で、それが現在表し
     // アプリケーションのすべての状況
     //はCPUコア必要のアプリケーション最大数、どのくらいのメモリ各スレーブ含む

    ヴァルappDesc = 新しい新しいApplicationDescription（sc.appName、MaxCoresを、皮下。 executorMemoryは、コマンド、
      appUIAddress、sc.eventLogDir、sc.eventLogCodec）が

    // でappclientを作成します
     //でappclientは、クラスタリングとスパークを介して実行アプリケーションの責任であるインタフェースであり、手紙。  
    // これは、SparkマスターのURLを受け取り、アプリケーション、および 
     // クラスタのイベントリスナーを、そして様々なイベントは、コールバックリスナー発生した場合

    、クライアント =新しい新でappclient（sc.env.actorSystem、マスターズ、appDescを、この、CONF）
    client.start（）

    waitForRegistration（）
  }

2、DAGScheduler作成します

SparkContext.scala ### 

 @ 揮発 プライベート [スパーク]のvar dagScheduler：DAGScheduler = _
   試し{
   // DAGSchedulerクラスは、ステージが直面している高レベルスケジューリング機構スケジューリング層を実装して、彼は（各段階の仕事のためにDAGを計算します有向非巡回グラフ）、
 // か出力段のトラックとRDDは客体（それがマテリア、またはディスク・メモリや他の場所に書き込まれる）と最小を探し
 // 消費（最適最小値）スケジューリング機構ジョブを実行する、基礎となるTaskSchedulerImpleにタスクセットの段階として提出されます
 // クラスタ（タスク）上でそれらを実行するために
 // DAGの処理段階に加えて、それが現在に基づいて、各タスクを実行するのに最適な場所を決定する責任がありますバッファ状態は、これらの最高の位置の下に提出されます
 // TaskSchedulerImpl。また、出力ファイルをシャッフルするために失敗の理由が原因この場合には、昔のステージがあります、に不足しているに対処します
 // ファイルが結果として表示されませんshuffleに起因しない場合は、それは意志、内部ステージに失敗し、再送信しますそれは再試行の回数となり、処理されるのTaskSchedule
 // 最後に、それだけでステージ全体をキャンセルすること、死ぬことになるまで、各タスク
    dagScheduler = 新しい DAGScheduler（この）
  } キャッチ{
     ケース E：例外=> {
       しようと{ 
        ストップ（）
      } 最後に{
         スロー 新しい SparkExceptionを（ "エラーDAGScheduler構築中" 、e）を
      } 
    } 
  }

3、SparkUI作成

### SparkContext.scalaは

// スパークUI初期化
  プライベート [SparkUI] =オプション：[スパーク]ヴァルUI
     場合（conf.getBoolean（ "spark.ui.enabled" 真））{ 
      一部（SparkUI.createLiveUI（これを、 CONF、listenerBus、jobProgressListener、
        env.securityManager、appNameの））
    } 他{
       // テストでは、UIを有効にしません
      なし
    } 




### SparkUI.scall 

// 默认端口 
ヴァルDEFAULT_PORT = 4040 
DEF createLiveUI（
      SC：SparkContext、
      CONFを：SparkConf、
      listenerBus：SparkListenerBus、
      jobProgressListener：JobProgressListener、
      セキュリティマネージャ：セキュリティマネージャ、
      appNameの：文字列）：SparkUI =   { 
    （一部（SC）を作成し、CONF、listenerBus、セキュリティマネージャ、appNameは、
      jobProgressListener = 一部（jobProgressListener））
  }