From bf0c326b7d7d1d21d364fdee64d440341a57a1aa Mon Sep 17 00:00:00 2001 From: Ozge Date: Fri, 25 Jul 2025 12:51:02 +0000 Subject: [PATCH 01/13] Add a link steps --- tests/training/add_a_link/conftest.py | 23 +- .../add_a_link/test_filter_dict_anchor.py | 52 +++ .../add_a_link/test_generate_addlink_model.py | 43 ++ .../test_generate_anchor_dictionary.py | 80 +++- .../test_generate_backtesting_data.py | 82 ++++ .../test_generate_backtesting_eval.py | 40 ++ .../add_a_link/test_generate_training_data.py | 22 + .../add_a_link/test_generate_wdproperties.py | 55 +++ training/add_a_link/pyproject.toml | 1 + .../src/add_a_link/filter_dict_anchor.py | 124 +++++ .../src/add_a_link/generate_addlink_model.py | 220 +++++++++ .../add_a_link/generate_backtesting_data.py | 183 ++++++++ .../add_a_link/generate_backtesting_eval.py | 231 ++++++++++ .../src/add_a_link/generate_training_data.py | 428 ++++++++++++++++++ .../src/add_a_link/generate_wdproperties.py | 136 ++++++ 15 files changed, 1697 insertions(+), 23 deletions(-) create mode 100644 tests/training/add_a_link/test_filter_dict_anchor.py create mode 100644 tests/training/add_a_link/test_generate_addlink_model.py create mode 100644 tests/training/add_a_link/test_generate_backtesting_data.py create mode 100644 tests/training/add_a_link/test_generate_backtesting_eval.py create mode 100644 tests/training/add_a_link/test_generate_training_data.py create mode 100644 tests/training/add_a_link/test_generate_wdproperties.py create mode 100644 training/add_a_link/src/add_a_link/filter_dict_anchor.py create mode 100644 training/add_a_link/src/add_a_link/generate_addlink_model.py create mode 100644 training/add_a_link/src/add_a_link/generate_backtesting_data.py create mode 100644 training/add_a_link/src/add_a_link/generate_backtesting_eval.py create mode 100644 training/add_a_link/src/add_a_link/generate_training_data.py create mode 100644 training/add_a_link/src/add_a_link/generate_wdproperties.py diff --git a/tests/training/add_a_link/conftest.py b/tests/training/add_a_link/conftest.py index 0038070..8497858 100644 --- a/tests/training/add_a_link/conftest.py +++ b/tests/training/add_a_link/conftest.py @@ -1,20 +1,21 @@ -import pytest -from pyspark.sql import DataFrame, SparkSession -from collections.abc import Generator -from pyspark.sql.types import ( - StructType, StructField, StringType, LongType, MapType, StructType, StructField -) import os +from collections.abc import Generator + +import pytest +from pyspark.sql import SparkSession os.environ["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"] = "YES" + @pytest.fixture(scope="session") def spark() -> Generator[SparkSession, None, None]: """Spark session with eager evaluation enabled.""" - spark = (SparkSession.builder.master("local[*]").appName("test") - .config("spark.executor.memory", "1g") - .config("spark.driver.memory", "1g") - .getOrCreate() - ) + spark = ( + SparkSession.builder.master("local[*]") + .appName("test") + .config("spark.executor.memory", "1g") + .config("spark.driver.memory", "1g") + .getOrCreate() + ) yield spark spark.stop() diff --git a/tests/training/add_a_link/test_filter_dict_anchor.py b/tests/training/add_a_link/test_filter_dict_anchor.py new file mode 100644 index 0000000..6a426b3 --- /dev/null +++ b/tests/training/add_a_link/test_filter_dict_anchor.py @@ -0,0 +1,52 @@ +from add_a_link import filter_dict_anchor +from pyspark.sql import Row + + +def test_filter_duplicate_page_ids(spark): + data = [ + Row(wiki_db="enwiki", title="A", page_id=1), + Row(wiki_db="enwiki", title="B", page_id=2), + Row(wiki_db="enwiki", title="A", page_id=3), # duplicate title + Row(wiki_db="dewiki", title="C", page_id=4), + ] + df = spark.createDataFrame(data) + result_df = filter_dict_anchor.filter_duplicate_page_ids(df) + result = result_df.collect() + # Only titles with a single occurrence should remain + titles = {row.title for row in result} + assert titles == {"B", "C"} + + +def test_filter_links_associated_with_unwanted_qids(spark): + # pageid_df + pageid_data = [ + Row(wiki_db="enwiki", page_id=1, title="A"), + Row(wiki_db="enwiki", page_id=2, title="B"), + ] + pageid_df = spark.createDataFrame(pageid_data) + # wdproperties_df + wdproperties_data = [ + Row(wiki_db="enwiki", page_id=1, statement_value_qid=["Q1", "Q2"]), + Row( + wiki_db="enwiki", page_id=2, statement_value_qid=["Q4167410"] + ), # unwanted QID + ] + wdproperties_df = spark.createDataFrame(wdproperties_data) + unwanted_qids = {"Q4167410"} + # anchors_df + anchors_data = [ + Row(wiki_db="enwiki", anchor="anchor1", link_occurrence={"A": 1, "B": 2}), + ] + anchors_schema = "wiki_db string, anchor string, link_occurrence map" + anchors_df = spark.createDataFrame(anchors_data, schema=anchors_schema) + # Apply transformation + transform = filter_dict_anchor.filter_links_associated_with_unwanted_qids( + pageid_df, wdproperties_df, unwanted_qids + ) + result_df = transform(anchors_df) + result = result_df.collect() + # Only link 'A' should remain, as 'B' is associated with an unwanted QID + assert len(result) == 1 + link_occ = result[0]["link_occurrence"] + assert "A" in link_occ + assert "B" not in link_occ diff --git a/tests/training/add_a_link/test_generate_addlink_model.py b/tests/training/add_a_link/test_generate_addlink_model.py new file mode 100644 index 0000000..b7f9afc --- /dev/null +++ b/tests/training/add_a_link/test_generate_addlink_model.py @@ -0,0 +1,43 @@ +import numpy as np +import pandas as pd +from add_a_link import generate_addlink_model as gam +from sklearn.preprocessing import OrdinalEncoder + + +def make_sample_df(): + # Create a small DataFrame with all required columns + data = { + "ngram": [1, 2, 1, 2], + "freq": [0.1, 0.2, 0.3, 0.4], + "ambig": [0, 1, 0, 1], + "kurtosis": [2.0, 3.0, 2.5, 3.5], + "w2v": [0.5, 0.6, 0.7, 0.8], + "levenshtein": [0.9, 0.8, 0.7, 0.6], + "wiki_db": ["enwiki", "enwiki", "enwiki", "enwiki"], + "label": [1, 0, 1, 0], + } + return pd.DataFrame(data) + + +def test_get_training_data_shapes_and_types(): + df = make_sample_df() + X_train, X_test, y_train, y_test, encoder = gam.get_training_data(df) + # Check shapes + assert X_train.shape[1] == 7 + assert X_test.shape[1] == 7 + assert y_train.ndim == 1 + assert y_test.ndim == 1 + # Check encoder is OrdinalEncoder + assert isinstance(encoder, OrdinalEncoder) + # Check that wiki_db column is encoded as numbers + assert np.issubdtype(df["wiki_db"].dtype, np.floating) + + +def test_get_training_data_stratification(): + df = make_sample_df() + # Duplicate rows to ensure stratification is possible + df = pd.concat([df] * 10, ignore_index=True) + X_train, X_test, y_train, y_test, encoder = gam.get_training_data(df) + # Check that both train and test have both classes + assert set(y_train) == {0, 1} + assert set(y_test) == {0, 1} diff --git a/tests/training/add_a_link/test_generate_anchor_dictionary.py b/tests/training/add_a_link/test_generate_anchor_dictionary.py index 82d73a6..38a48dd 100644 --- a/tests/training/add_a_link/test_generate_anchor_dictionary.py +++ b/tests/training/add_a_link/test_generate_anchor_dictionary.py @@ -1,14 +1,40 @@ -import pytest -from pyspark.sql import SparkSession -from pyspark.sql import Row from add_a_link import generate_anchor_dictionary as gad + def test_enrich_with_articles_basic(spark): data = [ - {"wiki_db": "enwiki", "page_namespace": 0, "page_id": 1, "page_title": "Test Page", "page_redirect_title": "", "revision_text": "Some text"}, - {"wiki_db": "enwiki", "page_namespace": 0, "page_id": 2, "page_title": "Redirect Page", "page_redirect_title": "Target", "revision_text": "#REDIRECT [[Target]]"}, - {"wiki_db": "enwiki", "page_namespace": 1, "page_id": 3, "page_title": "Talk:Test", "page_redirect_title": "", "revision_text": "Talk page"}, - {"wiki_db": "frwiki", "page_namespace": 0, "page_id": 4, "page_title": "French Page", "page_redirect_title": "", "revision_text": "Texte"}, + { + "wiki_db": "enwiki", + "page_namespace": 0, + "page_id": 1, + "page_title": "Test Page", + "page_redirect_title": "", + "revision_text": "Some text", + }, + { + "wiki_db": "enwiki", + "page_namespace": 0, + "page_id": 2, + "page_title": "Redirect Page", + "page_redirect_title": "Target", + "revision_text": "#REDIRECT [[Target]]", + }, + { + "wiki_db": "enwiki", + "page_namespace": 1, + "page_id": 3, + "page_title": "Talk:Test", + "page_redirect_title": "", + "revision_text": "Talk page", + }, + { + "wiki_db": "frwiki", + "page_namespace": 0, + "page_id": 4, + "page_title": "French Page", + "page_redirect_title": "", + "revision_text": "Texte", + }, ] df = spark.createDataFrame(data) result = gad.enrich_with_articles(df, ["enwiki"]) @@ -18,12 +44,41 @@ def test_enrich_with_articles_basic(spark): assert rows[0]["title"].lower() == "test page" assert rows[0]["wiki_db"] == "enwiki" + def test_enrich_with_redirects_basic(spark): data = [ - {"wiki_db": "enwiki", "page_namespace": 0, "page_id": 1, "page_title": "Test Page", "page_redirect_title": "", "revision_text": "Some text"}, - {"wiki_db": "enwiki", "page_namespace": 0, "page_id": 2, "page_title": "Redirect Page", "page_redirect_title": "Target", "revision_text": "#REDIRECT [[Target]]"}, - {"wiki_db": "enwiki", "page_namespace": 1, "page_id": 3, "page_title": "Talk:Test", "page_redirect_title": "", "revision_text": "Talk page"}, - {"wiki_db": "frwiki", "page_namespace": 0, "page_id": 4, "page_title": "French Page", "page_redirect_title": "", "revision_text": "Texte"}, + { + "wiki_db": "enwiki", + "page_namespace": 0, + "page_id": 1, + "page_title": "Test Page", + "page_redirect_title": "", + "revision_text": "Some text", + }, + { + "wiki_db": "enwiki", + "page_namespace": 0, + "page_id": 2, + "page_title": "Redirect Page", + "page_redirect_title": "Target", + "revision_text": "#REDIRECT [[Target]]", + }, + { + "wiki_db": "enwiki", + "page_namespace": 1, + "page_id": 3, + "page_title": "Talk:Test", + "page_redirect_title": "", + "revision_text": "Talk page", + }, + { + "wiki_db": "frwiki", + "page_namespace": 0, + "page_id": 4, + "page_title": "French Page", + "page_redirect_title": "", + "revision_text": "Texte", + }, ] df = spark.createDataFrame(data) result = gad.enrich_with_redirects(df, ["enwiki"]) @@ -34,6 +89,7 @@ def test_enrich_with_redirects_basic(spark): assert rows[0]["title_to"].lower() == "target" assert rows[0]["wiki_db"] == "enwiki" + def test_links_udf(): wikitext = "This is a [[Link1|Anchor1]] and [[Link2]]." result = gad.links.func(wikitext) @@ -42,4 +98,4 @@ def test_links_udf(): anchors = {pl.anchor for pl in result} links = {pl.link for pl in result} assert "anchor1" in anchors or "link1" in anchors - assert "Link2" in links \ No newline at end of file + assert "Link2" in links diff --git a/tests/training/add_a_link/test_generate_backtesting_data.py b/tests/training/add_a_link/test_generate_backtesting_data.py new file mode 100644 index 0000000..8a3a663 --- /dev/null +++ b/tests/training/add_a_link/test_generate_backtesting_data.py @@ -0,0 +1,82 @@ +from add_a_link import generate_backtesting_data +from pyspark.sql import Row + + +def test_filter_qualifying_wikitext(spark): + data = [ + Row( + wiki_db="enwiki", + page_namespace=0, + page_redirect_title="", + revision_text="Some text", + page_title="Article1", + ), + Row( + wiki_db="enwiki", + page_namespace=1, + page_redirect_title="", + revision_text="Some text", + page_title="Article2", + ), + Row( + wiki_db="enwiki", + page_namespace=0, + page_redirect_title="Redirect", + revision_text="Some text", + page_title="Article3", + ), + Row( + wiki_db="enwiki", + page_namespace=0, + page_redirect_title="", + revision_text=None, + page_title="Article4", + ), + Row( + wiki_db="enwiki", + page_namespace=0, + page_redirect_title="", + revision_text="", + page_title="Article5", + ), + Row( + wiki_db="enwiki", + page_namespace=0, + page_redirect_title="", + revision_text="Some text", + page_title="Wikipedia:Test", + ), + Row( + wiki_db="dewiki", + page_namespace=0, + page_redirect_title="", + revision_text="Some text", + page_title="Article6", + ), + ] + df = spark.createDataFrame(data) + wiki_dbs = ["enwiki"] + result_df = generate_backtesting_data.filter_qualifying_wikitext(df, wiki_dbs) + result = result_df.collect() + # Only the first row should pass all filters + assert len(result) == 1 + assert result[0].wiki_db == "enwiki" + assert result[0].page_title == "Article1" + + +def test_extract_linked_sentences(): + # This is a UDF, so we test the underlying function logic + # Example with a simple wikitext containing a link + wikitext = "This is a sentence with a [[Link]]. Another sentence." + language_code = "en" + result = generate_backtesting_data.extract_linked_sentences.func( + wikitext, language_code + ) + # Should return a sentence containing a link (or None if not found) + assert result is None or "Link" in result or "link" in result + # Example with no links + wikitext_no_link = "This is a sentence without a link." + result2 = generate_backtesting_data.extract_linked_sentences.func( + wikitext_no_link, language_code + ) + assert result2 is None diff --git a/tests/training/add_a_link/test_generate_backtesting_eval.py b/tests/training/add_a_link/test_generate_backtesting_eval.py new file mode 100644 index 0000000..6440eba --- /dev/null +++ b/tests/training/add_a_link/test_generate_backtesting_eval.py @@ -0,0 +1,40 @@ +from add_a_link import generate_backtesting_eval as gbe +from pyspark.sql import Row + + +def test_to_dict_basic(spark): + data = [ + Row(key="a", value=1), + Row(key="b", value=2), + Row(key="c", value=3), + ] + df = spark.createDataFrame(data) + result = gbe.to_dict(df, "key", "value") + assert result == {"a": 1, "b": 2, "c": 3} + + +def test_to_dict_with_nonstring_keys(spark): + data = [ + Row(key=1, value="foo"), + Row(key=2, value="bar"), + ] + df = spark.createDataFrame(data) + result = gbe.to_dict(df, "key", "value") + assert result == {1: "foo", 2: "bar"} + + +def test_to_dict_empty_df(spark): + df = spark.createDataFrame([], "key string, value int") + result = gbe.to_dict(df, "key", "value") + assert result == {} + + +def test_to_dict_duplicate_keys(spark): + # If duplicate keys, pandas set_index will keep the last occurrence + data = [ + Row(key="x", value=1), + Row(key="x", value=2), + ] + df = spark.createDataFrame(data) + result = gbe.to_dict(df, "key", "value") + assert result == {"x": 2} diff --git a/tests/training/add_a_link/test_generate_training_data.py b/tests/training/add_a_link/test_generate_training_data.py new file mode 100644 index 0000000..bb0819a --- /dev/null +++ b/tests/training/add_a_link/test_generate_training_data.py @@ -0,0 +1,22 @@ +from add_a_link import generate_training_data as gtd +from pyspark.sql import Row + + +def test__filter_links_without_page(spark): + # links_df contains links to pages A, B, C + links_data = [ + Row(wiki_db="enwiki", link="A", parsed_link=Row(link="A")), + Row(wiki_db="enwiki", link="B", parsed_link=Row(link="B")), + Row(wiki_db="enwiki", link="C", parsed_link=Row(link="C")), + ] + links_df = spark.createDataFrame(links_data) + # pageids_df contains only A and C + pageids_data = [ + Row(wiki_db="enwiki", page_id=1, title="A"), + Row(wiki_db="enwiki", page_id=2, title="C"), + ] + pageids_df = spark.createDataFrame(pageids_data) + transform = gtd._filter_links_without_page(pageids_df) + result_df = transform(links_df) + result = {row.link for row in result_df.collect()} + assert result == {"A", "C"} diff --git a/tests/training/add_a_link/test_generate_wdproperties.py b/tests/training/add_a_link/test_generate_wdproperties.py new file mode 100644 index 0000000..f608fb9 --- /dev/null +++ b/tests/training/add_a_link/test_generate_wdproperties.py @@ -0,0 +1,55 @@ +from add_a_link import generate_wdproperties +from pyspark.sql import Row + + +def test_filter_main_namespace_page_links(spark): + data = [ + Row(wiki_db="enwiki", page_namespace=0), + Row(wiki_db="enwiki", page_namespace=1), + Row(wiki_db="dewiki", page_namespace=0), + ] + df = spark.createDataFrame(data) + wiki_dbs = ["enwiki"] + result_df = generate_wdproperties.filter_main_namespace_page_links(wiki_dbs)(df) + result = result_df.collect() + assert all(row.wiki_db == "enwiki" and row.page_namespace == 0 for row in result) + assert len(result) == 1 + + +def test_enrich_with_parsed_wikidata_value(spark): + # Only the first row should match all filters and be parsed + data = [ + Row( + claim=Row( + mainSnak=Row( + dataType="wikibase-item", + property="P31", + dataValue=Row(value='{"id": "Q5"}'), + ) + ), + wiki_db="enwiki", + page_id=1, + item_id="Q1", + ), + Row( + claim=Row( + mainSnak=Row( + dataType="string", + property="P31", + dataValue=Row(value='{"id": "Q5"}'), + ) + ), + wiki_db="enwiki", + page_id=2, + item_id="Q2", + ), + ] + df = spark.createDataFrame(data) + wikidata_properties = ["P31"] + result_df = generate_wdproperties._enrich_with_parsed_wikidata_value( + wikidata_properties + )(df) + result = result_df.collect() + # Only the first row should be included and Q5 should be in the set + assert len(result) == 1 + assert result[0]["statement_value_qid"] == ["Q5"] diff --git a/training/add_a_link/pyproject.toml b/training/add_a_link/pyproject.toml index 8fb7a09..b404f36 100644 --- a/training/add_a_link/pyproject.toml +++ b/training/add_a_link/pyproject.toml @@ -22,6 +22,7 @@ dependencies = [ "scikit-learn==1.0.2", "ipykernel==6.29.5", "research-common @ git+https://gitlab.wikimedia.org/repos/research/research-common.git@v0.2.0", + "fsspec==2025.7.0", ] [project.optional-dependencies] diff --git a/training/add_a_link/src/add_a_link/filter_dict_anchor.py b/training/add_a_link/src/add_a_link/filter_dict_anchor.py new file mode 100644 index 0000000..8c29f63 --- /dev/null +++ b/training/add_a_link/src/add_a_link/filter_dict_anchor.py @@ -0,0 +1,124 @@ +import pathlib + +import click +from pyspark.sql import DataFrame, SparkSession, functions as F, types as T + +from add_a_link.pipeline_transformations.transformation import Transformation + +list_qid_filter = { + # non-content pages + "Q4167410", # disambiguation-pages + "Q13406463", # list-pages + # dates + "Q3186692", # calendar year-pages + "Q577", # year + "Q573", # day + "Q39911", # decade + "Q578", # century + "Q36507", # millenium + "Q47150325", # calendar day of a given year + "Q47018478", # calendar month of a given year + "Q205892", # calendar date + "Q14795564", # Point in time with respect to recurrent timeframe + "Q18340514", # events in a specific year or time period + # units + "Q1978718", # unit of length + "Q1790144", # unit of time + "Q1302471", # unit of volume + "Q3647172", # unit of mass + "Q2916980", # unit of energy + "Q3550873", # unit of information + "Q8142", # currency + "Q27084", # parts-per-notation + # names + "Q202444", # given name + "Q1243157", # double name + "Q3409032", # unisex given name + "Q12308941", # male given name + "Q11879590", # female given name +} + + +def filter_duplicate_page_ids(pageid_df: DataFrame) -> DataFrame: + # it is possible to have multiple page ids with the same title, + # this affects only a small number of pages, and are usually fixed quickly + # in the live DB but happened during the database export. + return ( + pageid_df.groupBy("wiki_db", "title") + .agg(F.count("*").alias("count"), F.first("page_id").alias("page_id")) + .where(F.col("count") == 1) + .drop("count") + ) + + +def filter_links_associated_with_unwanted_qids( + pageid_df: DataFrame, wdproperties_df: DataFrame, unwanted_qids: set[str] +) -> Transformation: + @F.udf(returnType=T.BooleanType()) + def link_associated_with_unwanted_qid(link_qids: list[str]) -> bool: + # returns True if any unwanted qid is associated with a link + # returns False if there are no qids are associated with a link + return bool(unwanted_qids.intersection(link_qids)) if link_qids else False + + links_wd = wdproperties_df.join(pageid_df, on=["wiki_db", "page_id"], how="inner") + + def _(anchors_df: DataFrame) -> DataFrame: + # join to enrich anchor links with page id and qids of links + anchors_with_page_and_wikidata_df = ( + anchors_df.select( + "wiki_db", + "anchor", + F.explode("link_occurrence").alias("title", "count"), + ) + .join(links_wd, on=["wiki_db", "title"], how="left") + .where(~link_associated_with_unwanted_qid("statement_value_qid")) + ) + # filter undesired links and reconstruct the re-aggregate to anchors map + return ( + anchors_with_page_and_wikidata_df.groupBy("wiki_db", "anchor") + .agg( + F.map_from_entries(F.collect_list(F.struct("title", "count"))).alias( + "link_occurrence" + ) + ) + .where(F.size("link_occurrence") > 0) + ) + + return _ + + +def run( + spark: SparkSession, + directory: pathlib.Path, +) -> None: + """ + Filters anchor dictionary that are an instance-of the `list_qid_filter` + Wikidata items + """ + anchors_df = spark.read.parquet(str(directory / "anchors")) + pageid_df = ( + spark.read.parquet(str(directory / "pageids")) + .withColumnRenamed("pid", "page_id") + .drop("wikitext") + .transform(filter_duplicate_page_ids) + ) + wdproperties_df = spark.read.parquet(str(directory / "wdproperties")) + + anchors_df.transform( + filter_links_associated_with_unwanted_qids( + pageid_df, wdproperties_df, list_qid_filter + ) + ).write.mode("overwrite").parquet(str(directory / "anchors_filtered")) + + +@click.command() +@click.option("--directory", required=True) +def main(directory: str): + # will re-use previously created sessions if there is any e.g airflow + spark = SparkSession.builder.getOrCreate() + directory_input = pathlib.Path(directory) + run(spark, directory=directory_input) + + +if __name__ == "__main__": + main() diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py new file mode 100644 index 0000000..71432d6 --- /dev/null +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -0,0 +1,220 @@ +import multiprocessing +import pathlib +from collections.abc import Sequence + +import click +import fsspec # type: ignore[import-untyped] +import joblib # type: ignore[import-untyped] +import pandas as pd +import xgboost +from sklearn import model_selection # type: ignore[import-untyped] +from sklearn.metrics import ( # type: ignore[import-untyped] + average_precision_score, + f1_score, + roc_auc_score, +) +from sklearn.model_selection import ( # type: ignore[import-untyped] + GridSearchCV, + StratifiedShuffleSplit, +) +from sklearn.preprocessing import OrdinalEncoder # type: ignore[import-untyped] + +from add_a_link.utils import hdfs_path + +seed = 7 +max_train_samples = 10_000_000 # for combined model +max_train_samples_grid = 50000 # for grid_search + + +def get_training_data( + df: pd.DataFrame, +) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame, pd.DataFrame, OrdinalEncoder]: + # use OrdinalEncoder to encode wiki_db as categorical feature for the model + wiki_db_encoder = OrdinalEncoder( + handle_unknown="use_encoded_value", unknown_value=-1 + ) + df["wiki_db"] = wiki_db_encoder.fit_transform( + df["wiki_db"].to_numpy().reshape(-1, 1) + ) # encode wiki_db + + # split data into X and y (features and labels) + features = ["ngram", "freq", "ambig", "kurtosis", "w2v", "levenshtein", "wiki_db"] + X = df[features].values + Y = df["label"].values.astype(int) + + stratify_data = [f"{x}_{y}" for x, y in zip(df["wiki_db"].values, Y)] + + # Generate a random Train/Test split + # note: the dataset is large enough to avoid Cross Validation + test_size = 0.33 + split_dfs = model_selection.train_test_split( + X, Y, test_size=test_size, random_state=seed, stratify=stratify_data + ) + X_train, X_test, y_train, y_test = split_dfs + return X_train, X_test, y_train, y_test, wiki_db_encoder + + +def perform_grid_search(df_small: pd.DataFrame, n_cpus_max: int) -> GridSearchCV: + X_train, X_test, y_train, y_test, _ = get_training_data(df_small) + + # Define the hyperparameter grid + # default eta: 0.3, max_depth 6, subsample 1, estimators 100 + param_grid = { + "max_depth": [ + 6, + 8, + 10, + 12, + ], # depth leads to overfitting # if overfits, tune gamma, lambda, alpha + "learning_rate": [0.7, 0.5, 0.3, 0.1, 0.01, 0.001], + # 'subsample': [0.5, 0.7, 1], # lowering will prevent overfitting by training on + # a subset of data + "n_estimators": [40, 70, 100, 130, 160, 190, 250], + } + + # Create the XGBoost model object + xgb_model = xgboost.XGBClassifier(n_jobs=n_cpus_max, tree_method="approx") + + # get CV splits (1 split is enough for this large dataset) + cv = StratifiedShuffleSplit(n_splits=1, random_state=seed, test_size=0.3) + + # Create the GridSearchCV object + grid_search_model = GridSearchCV( + xgb_model, + param_grid, + cv=cv, + scoring=["roc_auc", "f1", "average_precision"], + refit="f1", + n_jobs=n_cpus_max, + verbose=3, + ) + grid_search_model.fit(X_train, y_train) + + # Print the best set of hyperparameters and the corresponding score + print("Best set of hyperparameters: ", grid_search_model.best_params_) + print("Best score: ", grid_search_model.best_score_) + + return grid_search_model + + +def run( # noqa: PLR0915 + wiki_dbs: Sequence[str], + model_id: str, + directory: pathlib.Path, + grid_search: bool = False, +) -> None: + """ + Trains and saves a language agnostic XGBoost model on one or more languages. + + :param wikis: List of Wiki IDs with which to train the model (e.g. enwiki) + :param model_id: Model name. Can be the Wiki ID for single language wiki + :param directory: Path to input/output directory + :param grid_search: Whether to perform grid search and store best model + """ + print("Number of Wikis:", len(wiki_dbs)) + + df = pd.DataFrame() + + if grid_search: + df_small = pd.DataFrame() + + for wiki in wiki_dbs: + try: + path = directory / "training" / "link_train.parquet" / f"wiki_db={wiki}" + wiki_df = pd.read_parquet(hdfs_path(path)) + wiki_df["wiki_db"] = wiki + except Exception as e: + print("ERROR: ", type(e).__name__, e) # if file not found, skip wiki + continue + + print(wiki, len(wiki_df)) + + if len(wiki_dbs) > 1: + # when a list of wikis is provided, training data from each language is + # downsampled to at most max_train_samples + wiki_df, _ = model_selection.train_test_split( + wiki_df, + train_size=min(len(wiki_df) - 2, max_train_samples), + random_state=seed, + stratify=wiki_df["label"], + ) + print("Reduced", wiki, len(wiki_df)) + df = pd.concat([df, wiki_df]) + else: + # for single-language models we dont downsample the training data + df = pd.concat([df, wiki_df]) + + if grid_search: + wiki_df_small, _ = model_selection.train_test_split( + wiki_df, + train_size=min(len(wiki_df) - 2, max_train_samples_grid), + random_state=seed, + stratify=wiki_df["label"], + ) + print("Reduced (grid search)", wiki, len(wiki_df_small)) + df_small = pd.concat([df_small, wiki_df_small]) + + print("Total training data size:", len(df)) + if grid_search: + print("Total training data size reduced:", len(df_small)) + + # Fit model to the training data + n_cpus_max = min([int(multiprocessing.cpu_count() / 4), 8]) + + if grid_search: + grid_search_model = perform_grid_search(df_small, n_cpus_max) + model = xgboost.XGBClassifier( + **grid_search_model.best_params_, n_jobs=n_cpus_max + ) + else: + model = xgboost.XGBClassifier( + n_estimators=250, max_depth=8, learning_rate=0.1, n_jobs=n_cpus_max + ) + + X_train, X_test, y_train, y_test, wiki_db_encoder = get_training_data(df) + + model.fit(X_train, y_train) + print(model) + + # evaluate predictions + predictions = model.predict_proba(X_test)[:, 1] + try: + print(f"ROC AUC={roc_auc_score(y_test, predictions):.3f}") + + preds = model.predict(X_test) + print(f"F1 SCORE={f1_score(y_test, preds):.3f}") + avg_prec = average_precision_score(y_test, predictions) + print(f"Average Precision Score={avg_prec:.3f}") + + except ValueError as e: + if ( + str(e) == "Only one class present in y_true. " + "ROC AUC score is not defined in that case." + ): + print("ROC AUC not defined") + else: + raise + + # save the model + link_model_path = directory / model_id / f"{model_id}.linkmodel.joblib" + with fsspec.open(hdfs_path(link_model_path), "wb") as file: + joblib.dump(model, file) + + encoder_path = directory / model_id / f"{model_id}.encoder.joblib" + with fsspec.open(hdfs_path(encoder_path), "wb") as file: + joblib.dump(wiki_db_encoder, file) + + +@click.command() +@click.option("--wiki_dbs", required=True, help="Comma-separated list of names") +@click.option("--model_id", required=True) +@click.option("--directory", required=True) +@click.option("--grid_search", type=bool, default=False, help="A boolean flag") +def main(wiki_dbs: str, model_id: str, directory: str, grid_search: bool): + directory_input = pathlib.Path(directory) + wiki_dbs_input = wiki_dbs.split(",") + run(wiki_dbs_input, model_id, directory_input, grid_search) + + +if __name__ == "__main__": + main() diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_data.py b/training/add_a_link/src/add_a_link/generate_backtesting_data.py new file mode 100644 index 0000000..16c4b71 --- /dev/null +++ b/training/add_a_link/src/add_a_link/generate_backtesting_data.py @@ -0,0 +1,183 @@ +import pathlib +import re +from collections.abc import Sequence + +import click +import mwparserfromhell as mwph # type: ignore[import-untyped] +from mwparserfromhell.nodes import Text, Wikilink # type: ignore[import-untyped] +from pyspark.sql import DataFrame, SparkSession, functions as F, types as T + +from add_a_link import utils +from add_a_link.ngram_utils import tokenize_sentence +from add_a_link.pipeline_transformations.transformation import ( + Transformation, + stratified_sample, +) +from add_a_link.wikitext_to_plaintext import ( + wikitext_to_plaintext, +) + +# Remove links to special content +regexes = [ + r"\|.*", + r"\s+", + "!.*", + r".*JPG\|", + r".*jpg\|", + r".*\}\}", + r".*\{\{", + ".* Transformation: + return ( + df.where(F.col("wiki_db").isin(*wiki_dbs)) + ## main namespace + .where(F.col("page_namespace") == 0) + # no redirect-pages + .where(F.col("page_redirect_title") == "") + .where(F.col("revision_text").isNotNull()) + .where(F.length(F.col("revision_text")) > 0) + .where(~F.col("page_title").startswith("Wikipedia:")) + .select("wiki_db", "page_title", "revision_text") + ) + + +@F.udf +def normalized_title(title: str) -> str: + return utils.normalise_title(title) + + +@F.udf(returnType=T.StringType()) +def extract_linked_sentences(wikitext: str, language_code: str) -> str | None: + """ + Returns the first sentence which originally contained a link, but with the + link removed + """ + plaintext = wikitext_to_plaintext(wikitext, language_code, "skip-lists") + if not isinstance(plaintext, str): + return None + tokenizer = utils.get_tokenizer(language_code) + # extract sentences and strip whitespace + sents = [sent.strip() for sent in tokenize_sentence(plaintext, tokenizer)] + # filters + sents = [sent for sent in sents if not re.match(combined, sent)] + for j in sents: + jmwp = mwph.parse(j) + check = True + for i in jmwp.nodes: + if not (isinstance(i, Text | Wikilink)): + check = False + # preserve sentences that have at least a link + if ( + check + and len(jmwp.nodes) > NUM_NODES + and len(jmwp.filter_wikilinks()) > NUM_LINKS + ): + # j is the sentence + return j + + return None + + +def enrich_with_link_sentences( + df: DataFrame, canonical_wikis: DataFrame, max_sentences_per_wiki: int +) -> Transformation: + return ( + df.join( + F.broadcast( + canonical_wikis.select( + F.col("database_code").alias("wiki_db"), "language_code" + ) + ), + on="wiki_db", + ) + .withColumn( + "sentence", extract_linked_sentences("revision_text", "language_code") + ) + .where(F.col("sentence").isNotNull()) + .drop("revision_text", "language_code") + .transform( + stratified_sample( + cols=["wiki_db"], + strata_size=max_sentences_per_wiki, + seed=42, + ) + ) + ) + + +def run( + spark: SparkSession, + wiki_dbs: Sequence[str], + directory: pathlib.Path, + max_sentences_per_wiki: int = 200000, +) -> None: + """ + Generate a back testing dataset. + """ + + revision_content_col = F.col("revision_content_slots")["main"]["content_body"] + mediawiki_wikitext_current = ( + spark.table("wmf_content.mediawiki_content_current_v1") + .withColumn("revision_text", revision_content_col) + .withColumnRenamed("wiki_id", "wiki_db") + .withColumnRenamed("page_namespace_id", "page_namespace") + .withColumn( + "page_redirect_target", + F.when(F.col("page_redirect_target").isNull(), F.lit("")).otherwise( + F.col("page_redirect_target") + ), + ) + .withColumnRenamed("page_redirect_target", "page_redirect_title") + ) + linkless_sentences_df = ( + mediawiki_wikitext_current.transform( + lambda df: filter_qualifying_wikitext(df, wiki_dbs=wiki_dbs) + ) + .transform( + lambda df: enrich_with_link_sentences( + df, spark.table("canonical_data.wikis"), max_sentences_per_wiki + ) + ) + .withColumn(colName="page_title", col=normalized_title("page_title")) + ) + + # store two files + # training: to be used by the generate_training_data.py, because in the future + # we might want to use the whole sentence. + # test: this is effectively the data used by the backtesting protocol. + wiki_links_train, wiki_links_test = linkless_sentences_df.randomSplit( + [0.5, 0.5], seed=42 + ) + + wiki_links_train.write.mode("overwrite").parquet( + str(directory / "training/sentences_train.parquet") + ) + wiki_links_test.write.mode("overwrite").parquet( + str(directory / "testing/sentences_test.parquet") + ) + + +@click.command() +@click.option("--wiki_dbs", required=True, help="Comma-separated list of names") +@click.option("--directory", required=True) +@click.option("--max_sentences_per_wiki", required=False, default=200000) +def main(wiki_dbs: str, directory: str, max_sentences_per_wiki: str): + # will re-use previously created sessions if there is any e.g airflow + spark = SparkSession.builder.getOrCreate() + directory_input = pathlib.Path(directory) + wiki_dbs_input = wiki_dbs.split(",") + run(spark, wiki_dbs_input, directory_input, max_sentences_per_wiki) + + +if __name__ == "__main__": + main() diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py new file mode 100644 index 0000000..56708ae --- /dev/null +++ b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py @@ -0,0 +1,231 @@ +import multiprocessing +import pathlib +from collections.abc import Sequence +from math import nan +from typing import Any, cast + +import click +import fsspec # type: ignore[import-untyped] +import joblib # type: ignore[import-untyped] +import mwparserfromhell as mwph # type: ignore[import-untyped] +import pandas as pd +from mwtokenizer import Tokenizer # type: ignore[import-untyped] +from pyspark.sql import DataFrame, SparkSession, functions as F + +from add_a_link.utils import ( + get_language_code, + get_wiki_url, + getLinks, + hdfs_path, + process_page, +) + + +def to_dict(df: DataFrame, key_col: str, value_col: str) -> dict[str, Any]: + any_dict = ( + df.select(key_col, value_col).toPandas().set_index(key_col)[value_col].to_dict() + ) + return cast(dict[str, Any], any_dict) + + +def run( # noqa: PLR0915 + spark: SparkSession, + model_id: str, + wiki_dbs: Sequence[str], + directory: pathlib.Path, + thresholds: Sequence[float] = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9], + n_max: int | None = None, +) -> None: + """ + Performs backtesting evlauation of trained model on held-out testset. + + :param wiki_dbs: Wiki dbs for which to get recommendations + :param model_id: Model name with which to run evaluataion. Can be the + WIKI ID for language dependent evaluation + :param thresholds: Thresholds value for links to be recommended (set if you want to + evaluate for specific threshold values, if not specified, will evaluate for a range + 0.0, 0.1, ..., 0.9 + :param directory: Path to output directory + :param n_max: Maximum number of sentences to evaluate + """ + + anchors_df = ( + spark.read.parquet(str(directory / "anchors_filtered")) + .where(F.col("wiki_db").isin(*wiki_dbs)) + .cache() + ) + pageids_df = ( + spark.read.parquet(str(directory / "pageids")) + .withColumnRenamed("pid", "page_id") + .drop("wikitext") + .where(F.col("wiki_db").isin(*wiki_dbs)) + .cache() + ) + redirects_df = ( + spark.read.parquet(str(directory / "redirects")) + .where(F.col("wiki_db").isin(*wiki_dbs)) + .cache() + ) + embeddings_df = ( + spark.read.parquet(str(directory / "embeddings")) + .where(F.col("wiki_db").isin(*wiki_dbs)) + .cache() + ) + + sentences_df = ( + spark.read.parquet(str(directory / "testing/sentences_test.parquet")) + .where(F.col("wiki_db").isin(*wiki_dbs)) + .cache() + ) + + ## load the trained model + ## use a fourth of the cpus, at most 8 + n_cpus_max = min([int(multiprocessing.cpu_count() / 4), 8]) + + with fsspec.open( + hdfs_path(directory / model_id / f"{model_id}.linkmodel.joblib"), "rb" + ) as file: + model = joblib.load(file) + model.n_jobs = n_cpus_max + + with fsspec.open( + hdfs_path(directory / model_id / f"{model_id}.encoder.joblib"), "rb" + ) as file: + wiki_db_encoder = joblib.load(file) + + summary = df = pd.DataFrame() + for wiki_db in wiki_dbs: + anchors = to_dict( + anchors_df.where(F.col("wiki_db") == wiki_db), "anchor", "link_occurrence" + ) + + pageids = to_dict( + pageids_df.where(F.col("wiki_db") == wiki_db), "title", "page_id" + ) + + redirects = to_dict( + redirects_df.where(F.col("wiki_db") == wiki_db), "title_from", "title_to" + ) + + word2vec = to_dict( + embeddings_df.where(F.col("wiki_db") == wiki_db), "page_title", "embedding" + ) + + ## load the test-set + test_set = ( + sentences_df.where(F.col("wiki_db") == wiki_db) + .select("page_title", "sentence") + .toPandas() + .to_numpy() + .tolist() + ) + + wiki_url = get_wiki_url(wiki_db) + language_code = get_language_code(wiki_url) + tokenizer = Tokenizer(language_code=language_code) + + list_result = [] + for threshold in thresholds: + dict_eval = {} + print("threshold: ", threshold) + tot_TP = 0.0 + tot_rel = 0.0 + tot_ret = 0.0 + count_doc = 0 + for page, page_wikicode in test_set: + try: + input_code = page_wikicode + ## get links from original wikitext (and resolve redirects) + inp_pairs = getLinks( + input_code, redirects=redirects, pageids=pageids + ) + + ## if no links in main namespace, go to next item + if len(inp_pairs) == 0: + continue + + input_code_nolinks = mwph.parse(page_wikicode).strip_code() + output_code = process_page( + input_code_nolinks, + page, + anchors, + pageids, + redirects, + word2vec, + model, + wiki_db_encoder, + wiki_db, + language_code, + tokenizer, + threshold=threshold, + pr=False, + ) + + # output_code is wikicode but getLinks requires str + output_code = str(output_code) + + ## get links from predicted wikitext + out_pairs = getLinks( + output_code, redirects=redirects, pageids=pageids + ) + + TP = dict(set(inp_pairs.items()).intersection(out_pairs.items())) + tot_TP += len(TP) + tot_ret += len(out_pairs) + tot_rel += len(inp_pairs) + count_doc += 1 + except Exception as e: + print("ERROR: ", type(e).__name__, e) + pass + if count_doc == n_max: + break + + if tot_ret > 0: + micro_precision = tot_TP / tot_ret + else: + micro_precision = nan + if tot_rel > 0: + micro_recall = tot_TP / tot_rel + else: + micro_recall = nan + print(f"finished: {count_doc} sentences") + print("micro_precision:\t", micro_precision) + print("micro_recall:\t", micro_recall) + print("----------------------") + dict_eval["threshold"] = threshold + dict_eval["N"] = count_doc + dict_eval["micro_precision"] = micro_precision + dict_eval["micro_recall"] = micro_recall + list_result.append(dict_eval) + + df = pd.DataFrame.from_records(list_result).sort_values(by="threshold") + df["wiki_db"] = wiki_db + summary = pd.concat([summary, df]) + + with fsspec.open( + hdfs_path(directory / model_id / f"{model_id}.backtest.eval.csv"), "w" + ) as file: + summary.to_csv(file, index=False) + + +@click.command() +@click.option("--model_id", required=True) +@click.option("--wiki_dbs", required=True, help="Comma-separated list of names") +@click.option("--directory", required=True) +@click.option("--thresholds", required=False) +@click.option("--n_max", required=False, default=None) +def main(model_id: str, wiki_dbs: str, directory: str, thresholds: str, n_max: int): + # will re-use previously created sessions if there is any e.g airflow + spark = SparkSession.builder.getOrCreate() + wiki_dbs_input = wiki_dbs.split(",") + directory_input = pathlib.Path(directory) + if thresholds: + thresholds_input = thresholds.split(",") + else: + thresholds_input = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] + + run(spark, model_id, wiki_dbs_input, directory_input, thresholds_input, n_max) + + +if __name__ == "__main__": + main() diff --git a/training/add_a_link/src/add_a_link/generate_training_data.py b/training/add_a_link/src/add_a_link/generate_training_data.py new file mode 100644 index 0000000..7eb8213 --- /dev/null +++ b/training/add_a_link/src/add_a_link/generate_training_data.py @@ -0,0 +1,428 @@ +import pathlib +from collections.abc import Iterable, Iterator, Sequence + +import click +import mwparserfromhell as mwph # type: ignore[import-untyped] +import pandas as pd +import rbloom +import wikitextparser as wtp # type: ignore[import-untyped] +from Levenshtein import jaro as levenshtein_score +from mwtokenizer.config.symbols import ( # type: ignore[import-untyped] + ALL_UNICODE_PUNCTUATION, +) +from pyspark import SparkFiles +from pyspark.sql import DataFrame, SparkSession, functions as F, types as T +from scipy.stats import kurtosis # type: ignore[import-untyped] + +from add_a_link.generate_anchor_dictionary import ( + ParsedLink, + compute_hash, +) +from add_a_link.pipeline_transformations.transformation import Transformation +from add_a_link.utils import ( + embeddings_distance, + get_tokenizer, + ngram_iterator, + normalise_anchor, + normalise_title, + wtpGetLinkAnchor, +) + + +def _filter_links_without_page(pageids_df: DataFrame) -> Transformation: + def _(links_df: DataFrame) -> DataFrame: + return ( + links_df.alias("links") + .join( + pageids_df.where(F.col("page_id").isNotNull()).alias("pageids"), + on=( + (F.col("links.wiki_db") == F.col("pageids.wiki_db")) + & (F.col("links.link") == F.col("pageids.title")) + ), + how="inner", + ) + .select("links.*") + ) + + return _ + + +def _with_resolved_link_redirects(redirects_df: DataFrame) -> Transformation: + def _(links_df: DataFrame) -> DataFrame: + return ( + links_df.alias("links") + .join( + redirects_df.alias("redirects"), + on=( + (F.col("links.wiki_db") == F.col("redirects.wiki_db")) + & (F.col("links.parsed_link.link") == F.col("redirects.title_from")) + ), + how="left", + ) + .select( + "links.wiki_db", + "links.page_title", + "links.sentence", + F.col("parsed_link.anchor").alias("anchor"), + F.coalesce(F.col("title_to"), F.col("links.parsed_link.link")).alias( + "link" + ), + ) + ) + + return _ + + +def extract_candidate_anchors( + wiki_db: str, + language_code: str, + sentence: str, + existing_anchors: list[str], + anchors: rbloom.Bloom, +) -> list[str]: + """ + Extract valid anchor candidates + """ + tokenizer = get_tokenizer(language_code) + wikitext_nolinks = mwph.parse(sentence).strip_code() + tested_mentions = set() + for gram in ngram_iterator(wikitext_nolinks, tokenizer, 10, 1): + mention = gram.lower() + # if the mention exist in the DB + # it was not previously linked (or part of a link) + # none of its candidate links is already used + # it was not tested before (for efficiency) + if (wiki_db, mention) in anchors and mention not in tested_mentions: + tested_mentions.add(mention) + # we also add the mentions inp_pairs to make sure we have positive examples + for mention in existing_anchors: + if (wiki_db, mention) in anchors: + tested_mentions.add(mention) + return [normalise_anchor(mention) for mention in tested_mentions] + + +def enrich_with_candidate_anchors( + df: DataFrame, + spark: SparkSession, + canonical_wikis: DataFrame, + anchors_file: pathlib.Path, +) -> Transformation: + spark.sparkContext.addFile(path=str(anchors_file)) + + candidate_anchors_schema = T.StructType( + [ + T.StructField("wiki_db", T.StringType()), + T.StructField("page_title", T.StringType()), + T.StructField("anchor", T.StringType()), + ] + ) + + def candidate_anchors_udf( + sentence_batches: Iterable[pd.DataFrame], + ) -> Iterator[pd.DataFrame]: + # Load the bloom filter containing all known anchors ahead of + # processing any batches so we only load it once. + anchors = rbloom.Bloom.load(SparkFiles.get(anchors_file.name), compute_hash) + + for batch in sentence_batches: + batch["anchor"] = [ + extract_candidate_anchors( + wiki_db=wiki_db, + language_code=language_code, + sentence=sentence, + existing_anchors=[pl["anchor"] for pl in anchor_links], + anchors=anchors, + ) + for wiki_db, language_code, sentence, anchor_links in zip( + batch["wiki_db"], + batch["language_code"], + batch["sentence"], + batch["anchor_links"], + ) + ] + + # Explode candidates column into multiple rows. + df = batch.explode("anchor") + yield df[["wiki_db", "page_title", "anchor"]] + + return df.join( + F.broadcast( + canonical_wikis.select( + F.col("database_code").alias("wiki_db"), "language_code" + ) + ), + on="wiki_db", + ).mapInPandas( + candidate_anchors_udf, # type: ignore[arg-type] + schema=candidate_anchors_schema, + ) + + +def enrich_with_links( + df: DataFrame, + pageids_df: DataFrame, + redirects_df: DataFrame, +) -> Transformation: + """ + Parse anchor / link pairs + """ + + @F.udf( + returnType=T.ArrayType( + T.StructType( + [ + T.StructField("anchor", T.StringType()), + T.StructField("link", T.StringType()), + ] + ) + ) + ) + def extract_anchor_link_pairs(wikitext: str) -> list[ParsedLink]: + parsed_links = [] + for unparsed_link in wtp.parse(str(wikitext)).wikilinks: + link, anchor = wtpGetLinkAnchor(unparsed_link) + parsed_links.append(ParsedLink(anchor, link)) + return parsed_links + + return ( + df.withColumn("parsed_link", F.explode(extract_anchor_link_pairs("sentence"))) + .transform(_with_resolved_link_redirects(redirects_df)) + .transform(_filter_links_without_page(pageids_df)) + .groupBy("wiki_db", "page_title") + .agg( + F.collect_list(F.struct("anchor", "link")).alias("anchor_links"), + F.first(F.col("sentence")).alias("sentence"), + ) + ) + + +def _with_global_anchor_features(anchors_df: DataFrame) -> DataFrame: + @F.udf(returnType=T.FloatType()) + def kurtosis_udf(link_occurrence: dict[str, int], ambig: int) -> float: + # Skew of usage text/link distribution + return float( + kurtosis( + sorted(list(link_occurrence.values()), reverse=True) + + [1] * (1000 - ambig) + ) + ) + + return anchors_df.withColumn("ambig", F.size("link_occurrence")).withColumn( + "kurtosis", kurtosis_udf(F.col("link_occurrence"), F.col("ambig")) + ) + + +def _enrich_with_page_title(df: DataFrame, pageids_df: DataFrame) -> Transformation: + """ + Returns a dataframe that contains page title and embeddings vector + """ + + return ( + df.alias("embeddings") + .join( + pageids_df.alias("pageids"), + on=( + (F.col("embeddings.wiki_db") == F.col("pageids.wiki_db")) + & (F.col("embeddings.pid_from") == F.col("pageids.page_id")) + ), + ) + .select( + "pageids.wiki_db", + F.col("pageids.title").alias("page_title"), + "embeddings.embedding", + ) + ) + + +def enrich_with_ml_features( + df: DataFrame, + anchors_df: DataFrame, + embeddings_df: DataFrame, + pageids_df: DataFrame, + anchor_links_df: DataFrame, + canonical_wikis: DataFrame, +) -> Transformation: + @F.udf(returnType=T.IntegerType()) + def extract_label( + candidate: str, link: str, anchor_links: list[dict[str, str]] + ) -> int: + label = next( + ( + True + for pl in anchor_links + if (pl["anchor"] == candidate and pl["link"] == link) + ), + False, + ) + return int(label) + + @F.udf(returnType=T.IntegerType()) + def ngram(anchor: str, language_code: str) -> int: + tokenizer = get_tokenizer(language_code) + ngram = list( + tokenizer.word_tokenize(anchor, use_abbreviation=True) + ) # tokenize text + ngram = list( + filter(lambda x: not x.startswith(" "), ngram) + ) # could be a single or multiple spaces that needs to be removed + ngram = list( + filter(lambda x: x not in ALL_UNICODE_PUNCTUATION, ngram) + ) # remove punctuation + return len(ngram) + + candidate_anchors_with_features_df = ( + # enrich candidates with global anchor features + # also ensure that only previously existing anchors are candidates + df.join( + anchors_df.transform(_with_global_anchor_features), + on=["wiki_db", "anchor"], + how="inner", + ) + .join( + F.broadcast( + canonical_wikis.select( + F.col("database_code").alias("wiki_db"), "language_code" + ) + ), + on="wiki_db", + ) + .withColumn("ngram", ngram("anchor", "language_code")) + .drop("language_code") + # join with embedding of page + .join( + embeddings_df, + on=["wiki_db", "page_title"], + ) + .withColumnRenamed("embedding", "page_embedding") + # re-enrich the anchor_links array for label extraction + .join( + anchor_links_df.select(["wiki_db", "page_title", "anchor_links"]), + on=["wiki_db", "page_title"], + ) + ) + return ( + # explode the links for that page and enrich with features + candidate_anchors_with_features_df.select( + *candidate_anchors_with_features_df.columns, + F.explode("link_occurrence").alias("link", "freq"), + ) + .withColumn("link", F.udf(normalise_title, returnType=T.StringType())("link")) + .withColumn("label", extract_label("anchor", "link", "anchor_links")) + .withColumn( + "levenshtein", + F.udf(levenshtein_score, returnType=T.FloatType())( + F.lower("anchor"), F.lower("link") + ), + ) + .drop("link_occurrence", "anchor_links") + # join with embedding of page + .join( + embeddings_df.withColumnRenamed("page_title", "link"), + on=["wiki_db", "link"], + ) + .withColumnRenamed("embedding", "link_embedding") + .withColumn( + "w2v", + F.udf(embeddings_distance, returnType=T.FloatType())( + "page_embedding", "link_embedding" + ), + ) + .drop("link_embedding", "page_embedding") + ) + + +def run( + spark: SparkSession, + snapshot: str, + wiki_dbs: Sequence[str], + directory: pathlib.Path, + files_per_wiki: int = 20, + model_id="", +) -> None: + """ + Generates training dataset. + + This job extracts examples from the backtesting protocol + and reduces them to gold triple: (page, mention, link) + We turn the gold triple into features and generate negatives examples + Positive example: The correct link + Negative example: identified mentions and all candidate links + """ + anchors_file = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" + anchors_df = spark.read.parquet(str(directory / "anchors_filtered")) + pageids_df = ( + spark.read.parquet(str(directory / "pageids")) + .withColumnRenamed("pid", "page_id") + .drop("wikitext") + ) + redirects_df = spark.read.parquet(str(directory / "redirects")) + + canonical_wikis_df = spark.table("canonical_data.wikis") + + sentences_df = spark.read.parquet( + str(directory / "training/sentences_train.parquet") + ) + + embeddings_df = ( + spark.table("research.article_topics") + .where(F.col("snapshot") == snapshot) + .where(F.col("wiki_db").isin(*wiki_dbs)) + .transform(lambda df: _enrich_with_page_title(df, pageids_df)) + .alias("embeddings") + .cache() + ) + + anchor_links_df = sentences_df.transform( + lambda df: enrich_with_links(df, pageids_df, redirects_df) + ).cache() + features_df = anchor_links_df.transform( + lambda df: enrich_with_candidate_anchors( + df, spark, canonical_wikis_df, anchors_file + ) + ).transform( + lambda df: enrich_with_ml_features( + df, + anchors_df, + embeddings_df, + pageids_df, + anchor_links_df, + canonical_wikis_df, + ) + ) + + features_df.repartition(files_per_wiki).write.partitionBy("wiki_db").mode( + "overwrite" + ).parquet(str(directory / "training/link_train.parquet")) + + # save embeddings for inference + embeddings_df.repartition(files_per_wiki).write.partitionBy("wiki_db").mode( + "overwrite" + ).parquet(str(directory / "embeddings")) + + +@click.command() +@click.option("--snapshot", required=True, help="Snapshot date (e.g. 20230601)") +@click.option("--wiki_dbs", required=True, help="Comma-separated list of wiki DBs") +@click.option("--directory", required=True, help="Input/output directory") +@click.option( + "--files_per_wiki", + default=1, + show_default=True, + help="Number of output files per wiki", +) +@click.option("--model_id", required=True) +def main(snapshot, wiki_dbs, directory, files_per_wiki, model_id): + spark = SparkSession.builder.getOrCreate() + wiki_dbs_list = [db.strip() for db in wiki_dbs.split(",")] + run( + spark, + snapshot=snapshot, + wiki_dbs=wiki_dbs_list, + directory=pathlib.Path(directory), + files_per_wiki=files_per_wiki, + model_id=model_id, + ) + + +if __name__ == "__main__": + main() diff --git a/training/add_a_link/src/add_a_link/generate_wdproperties.py b/training/add_a_link/src/add_a_link/generate_wdproperties.py new file mode 100644 index 0000000..d682c80 --- /dev/null +++ b/training/add_a_link/src/add_a_link/generate_wdproperties.py @@ -0,0 +1,136 @@ +import pathlib +from collections.abc import Sequence + +import click +from pyspark.sql import DataFrame, SparkSession, functions as F + +from add_a_link.pipeline_transformations.transformation import Transformation + + +def filter_main_namespace_page_links(wiki_dbs: Sequence[str]) -> Transformation: + def _(wikidata_item_page_link_df: DataFrame) -> DataFrame: + return wikidata_item_page_link_df.where(F.col("wiki_db").isin(*wiki_dbs)).where( + F.col("page_namespace") == 0 + ) + + return _ + + +def _enrich_with_parsed_wikidata_value( + wikidata_properties: Sequence[str], +) -> Transformation: + def _(claims_with_page_df: DataFrame) -> DataFrame: + parsed_value_df = ( + claims_with_page_df.where( + F.col("claim.mainSnak.dataType") == "wikibase-item" + ) + .withColumn("statement_property", F.col("claim.mainSnak.property")) + .where(F.col("statement_property").isin(*wikidata_properties)) + .withColumn( + "parsed_value", + F.from_json(F.col("claim.mainSnak.dataValue.value"), "id string"), + ) + .where(F.col("parsed_value").isNotNull()) + .select( + "wiki_db", + "page_id", + "item_id", + "statement_property", + F.col("parsed_value.id").alias("statement_value"), + ) + ) + return parsed_value_df.groupby("wiki_db", "page_id").agg( + F.collect_set(F.col("statement_value")).alias("statement_value_qid") + ) + + return _ + + +def enrich_with_wikidata_statements( + wikidata_item_page_link_df: DataFrame, wikidata_properties: Sequence[str] +) -> Transformation: + def _(wikidata_entity_df: DataFrame) -> DataFrame: + claims_with_page_df = ( + wikidata_entity_df.withColumnRenamed("id", "item_id") + .where(F.col("claims").isNotNull()) + .join( + wikidata_item_page_link_df.select("item_id", "wiki_db", "page_id"), + on="item_id", + how="inner", + ) + .select( + "wiki_db", + "page_id", + "item_id", + F.explode(F.col("claims")).alias("claim"), + ) + ) + return claims_with_page_df.transform( + _enrich_with_parsed_wikidata_value(wikidata_properties) + ) + + return _ + + +def run( + spark: SparkSession, + wikidata_snapshot: str, + wiki_dbs: Sequence[str], + wikidata_properties: Sequence[str], + directory: pathlib.Path, +) -> None: + """ + Generates dictionary of Wikidata properties with which to filter achor dictionary. + """ + + wikidata_item_page_link_df = ( + spark.read.table("wmf.wikidata_item_page_link") + .where(F.col("snapshot") == wikidata_snapshot) + .transform(filter_main_namespace_page_links(wiki_dbs)) + ) + + wikidata_entity_df = spark.read.table("wmf.wikidata_entity").where( + F.col("snapshot") == wikidata_snapshot + ) + + ( + wikidata_entity_df.transform( + enrich_with_wikidata_statements( + wikidata_item_page_link_df, wikidata_properties + ) + ) + .write.mode("overwrite") + .parquet(str(directory / "wdproperties")) + ) + + +@click.command() +@click.option( + "--wikidata_snapshot", required=True, help="Wikidata snapshot date (e.g. 20230601)" +) +@click.option("--wiki_dbs", required=True, help="Comma-separated list of wiki DBs") +@click.option( + "--wikidata_properties", + required=True, + help="Comma-separated list of Wikidata properties", +) +@click.option("--directory", required=True, help="Output directory") +def main( + wikidata_snapshot: str, wiki_dbs: str, wikidata_properties: str, directory: str +): + # will re-use previously created sessions if there is any e.g airflow + spark = SparkSession.builder.getOrCreate() + wiki_dbs_list = [db.strip() for db in wiki_dbs.split(",")] + wikidata_properties_list = [prop.strip() for prop in wikidata_properties.split(",")] + directory_path = pathlib.Path(directory) + run( + spark, + wikidata_snapshot=wikidata_snapshot, + wiki_dbs=wiki_dbs_list, + wikidata_properties=wikidata_properties_list, + directory=directory_path, + ) + + +if __name__ == "__main__": + main() -- GitLab From 0c0d0f058a04e106ef9d21cc56b7c1526b3bccf7 Mon Sep 17 00:00:00 2001 From: ozge Date: Fri, 25 Jul 2025 15:52:16 +0200 Subject: [PATCH 02/13] feat: adds addalink steps --- training/add_a_link/.gitlab-ci.yml | 3 ++- .../add_a_link/src/add_a_link/generate_backtesting_data.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/training/add_a_link/.gitlab-ci.yml b/training/add_a_link/.gitlab-ci.yml index b0c4c80..519c7ef 100644 --- a/training/add_a_link/.gitlab-ci.yml +++ b/training/add_a_link/.gitlab-ci.yml @@ -45,4 +45,5 @@ pytest: stage: test extends: .job_template script: - - pytest ../../tests/training/add_a_link \ No newline at end of file + - pytest ../../tests/training/add_a_link + when: always \ No newline at end of file diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_data.py b/training/add_a_link/src/add_a_link/generate_backtesting_data.py index 16c4b71..c8bd856 100644 --- a/training/add_a_link/src/add_a_link/generate_backtesting_data.py +++ b/training/add_a_link/src/add_a_link/generate_backtesting_data.py @@ -18,7 +18,7 @@ from add_a_link.wikitext_to_plaintext import ( ) # Remove links to special content -regexes = [ +regexes = [ r"\|.*", r"\s+", "!.*", -- GitLab From 91b3fb1e0b0ab75914163973ff9e66f01b231f2b Mon Sep 17 00:00:00 2001 From: ozge Date: Mon, 28 Jul 2025 13:54:37 +0200 Subject: [PATCH 03/13] feat: adds addalink steps --- training/add_a_link/.gitlab-ci.yml | 14 ++++---- training/add_a_link/pyproject.toml | 6 ++++ .../add_a_link/notebooks/pipeline_run.ipynb | 34 ++++++++++++------- 3 files changed, 34 insertions(+), 20 deletions(-) diff --git a/training/add_a_link/.gitlab-ci.yml b/training/add_a_link/.gitlab-ci.yml index 519c7ef..b03a92b 100644 --- a/training/add_a_link/.gitlab-ci.yml +++ b/training/add_a_link/.gitlab-ci.yml @@ -5,7 +5,7 @@ default: stages: - - test + # - test - deploy @@ -41,9 +41,9 @@ publish_conda_env: - if: $CI_COMMIT_TAG when: on_success -pytest: - stage: test - extends: .job_template - script: - - pytest ../../tests/training/add_a_link - when: always \ No newline at end of file +# pytest: +# stage: test +# extends: .job_template +# script: +# - pytest ../../tests/training/add_a_link +# when: always \ No newline at end of file diff --git a/training/add_a_link/pyproject.toml b/training/add_a_link/pyproject.toml index b404f36..3cfe640 100644 --- a/training/add_a_link/pyproject.toml +++ b/training/add_a_link/pyproject.toml @@ -48,3 +48,9 @@ build-backend = "setuptools.build_meta" # They map a command-line name to a Python function. [project.scripts] "generate_anchor_dictionary.py" = "add_a_link.generate_anchor_dictionary:main" +"generate_wdproperties.py" = "add_a_link.generate_wdproperties.py:main" +"filter_dict_anchor.py" = "add_a_link.filter_dict_anchor.py:main" +"generate_backtesting_data.py" = "add_a_link.generate_backtesting_data.py:main" +"generate_training_data.py" = "add_a_link.generate_training_data.py:main" +"generate_addlink_model.py" = "add_a_link.generate_addlink_model.py:main" +"generate_backtesting_eval.py" = "add_a_link.generate_backtesting_eval.py:main" \ No newline at end of file diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index 0bc188a..33d079e 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -1660,10 +1660,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "d5aab157", "metadata": {}, "outputs": [], + "source": [ + "!hdfs dfs -chmod 777 /tmp/ozge" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "46d40bbe", + "metadata": {}, + "outputs": [], + "source": [ + "!hdfs dfs -mkdir -p /tmp/ozge" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6cf47121", + "metadata": {}, + "outputs": [], "source": [] } ], @@ -1672,18 +1692,6 @@ "display_name": "add_a_link_remote", "language": "python", "name": "add_a_link_remote" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" } }, "nbformat": 4, -- GitLab From 800427fa1602a40f90b73891066a59f4aa4e6c2e Mon Sep 17 00:00:00 2001 From: ozge Date: Tue, 29 Jul 2025 14:54:02 +0200 Subject: [PATCH 04/13] feat: adds addalink steps --- training/add_a_link/pyproject.toml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/training/add_a_link/pyproject.toml b/training/add_a_link/pyproject.toml index 3cfe640..070ca2e 100644 --- a/training/add_a_link/pyproject.toml +++ b/training/add_a_link/pyproject.toml @@ -48,9 +48,9 @@ build-backend = "setuptools.build_meta" # They map a command-line name to a Python function. [project.scripts] "generate_anchor_dictionary.py" = "add_a_link.generate_anchor_dictionary:main" -"generate_wdproperties.py" = "add_a_link.generate_wdproperties.py:main" -"filter_dict_anchor.py" = "add_a_link.filter_dict_anchor.py:main" -"generate_backtesting_data.py" = "add_a_link.generate_backtesting_data.py:main" -"generate_training_data.py" = "add_a_link.generate_training_data.py:main" -"generate_addlink_model.py" = "add_a_link.generate_addlink_model.py:main" -"generate_backtesting_eval.py" = "add_a_link.generate_backtesting_eval.py:main" \ No newline at end of file +"generate_wdproperties.py" = "add_a_link.generate_wdproperties:main" +"filter_dict_anchor.py" = "add_a_link.filter_dict_anchor:main" +"generate_backtesting_data.py" = "add_a_link.generate_backtesting_data:main" +"generate_training_data.py" = "add_a_link.generate_training_data:main" +"generate_addlink_model.py" = "add_a_link.generate_addlink_model:main" +"generate_backtesting_eval.py" = "add_a_link.generate_backtesting_eval:main" \ No newline at end of file -- GitLab From 5d29baa381cd3a8f4fae11294cb32d40be83248d Mon Sep 17 00:00:00 2001 From: ozge Date: Wed, 30 Jul 2025 13:50:09 +0200 Subject: [PATCH 05/13] feat: adds addalink steps --- training/add_a_link/src/add_a_link/README.md | 2 +- .../add_a_link/generate_anchor_dictionary.py | 28 +- .../add_a_link/generate_backtesting_data.py | 2 +- .../src/add_a_link/generate_training_data.py | 13 +- .../add_a_link/notebooks/pipeline_run.ipynb | 329 +++++++-------- .../add_a_link/notebooks/rbloom_example.ipynb | 384 ++++++++++++++++++ 6 files changed, 565 insertions(+), 193 deletions(-) create mode 100644 training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb diff --git a/training/add_a_link/src/add_a_link/README.md b/training/add_a_link/src/add_a_link/README.md index 33d20b3..e26209f 100644 --- a/training/add_a_link/src/add_a_link/README.md +++ b/training/add_a_link/src/add_a_link/README.md @@ -27,7 +27,7 @@ conda activate add_a_link pip install -e ".[dev]" # Step4: Run tests: -pre-commit run --files $(find add_a_link/src/add_a_link -name "*.py") +pre-commit run --files $(find . -name "*.py") pytest ../tests/add_a_link ``` diff --git a/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py b/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py index 9c2e978..3679ffd 100644 --- a/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py +++ b/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py @@ -5,6 +5,7 @@ import logging import pathlib import pickle import re +import subprocess from collections.abc import Iterable, Iterator, Sequence from dataclasses import dataclass from typing import Any @@ -296,7 +297,7 @@ def _with_link_probability( def _enrich_with_link_probability( - spark: SparkSession, articles_df: DataFrame, model_id + spark: SparkSession, articles_df: DataFrame, anchors_path: pathlib.Path ) -> Transformation: def _(links_df: DataFrame) -> DataFrame: linked_frequency_df = links_df.transform(_enrich_with_anchor_linked_frequency) @@ -311,7 +312,6 @@ def _enrich_with_link_probability( (row.wiki_db, row.anchor) for row in linked_frequency_df.select("wiki_db", "anchor").toLocalIterator() ) - anchors_path = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" make_bloom_filter( max_items=50_000_000, items=anchors, @@ -382,7 +382,10 @@ def enrich_with_redirects(df: DataFrame, wiki_dbs: Sequence[str]) -> Transformat def enrich_with_anchors( - df: DataFrame, spark: SparkSession, wiki_dbs: Sequence[str], model_id + df: DataFrame, + spark: SparkSession, + wiki_dbs: Sequence[str], + anchors_path: pathlib.Path, ) -> Transformation: filtered_wikitext_df = ( df.where(F.col("wiki_db").isin(*wiki_dbs)) @@ -415,7 +418,7 @@ def enrich_with_anchors( .transform(_filter_unlinkable_anchors(articles_df)) .transform( _enrich_with_link_probability( - spark=spark, articles_df=articles_df, model_id=model_id + spark=spark, articles_df=articles_df, anchors_path=anchors_path ) ) .where(F.col("link_probability") >= MIN_LINK_PROBABILITY) @@ -458,16 +461,29 @@ def run( .write.mode("overwrite") .parquet(str(output / "redirects")) ) - + anchors_path = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" ( mediawiki_wikitext_current.transform( lambda df: enrich_with_anchors( - df, spark=spark, wiki_dbs=wiki_dbs, model_id=model_id + df, spark=spark, wiki_dbs=wiki_dbs, anchors_path=anchors_path ), ) .write.mode("overwrite") .parquet(str(output / "anchors")) ) + anchors_hdfs_path = str(output / f"anchor_{model_id}.bloom") + subprocess.run( + ["hdfs", "dfs", "-rm", "-f", anchors_hdfs_path], + check=True, + capture_output=True, + text=True, + ) + subprocess.run( + ["hdfs", "dfs", "-put", str(anchors_hdfs_path), anchors_hdfs_path], + check=True, + capture_output=True, + text=True, + ) @click.command() diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_data.py b/training/add_a_link/src/add_a_link/generate_backtesting_data.py index c8bd856..16c4b71 100644 --- a/training/add_a_link/src/add_a_link/generate_backtesting_data.py +++ b/training/add_a_link/src/add_a_link/generate_backtesting_data.py @@ -18,7 +18,7 @@ from add_a_link.wikitext_to_plaintext import ( ) # Remove links to special content -regexes = [ +regexes = [ r"\|.*", r"\s+", "!.*", diff --git a/training/add_a_link/src/add_a_link/generate_training_data.py b/training/add_a_link/src/add_a_link/generate_training_data.py index 7eb8213..aa362b4 100644 --- a/training/add_a_link/src/add_a_link/generate_training_data.py +++ b/training/add_a_link/src/add_a_link/generate_training_data.py @@ -105,9 +105,10 @@ def enrich_with_candidate_anchors( df: DataFrame, spark: SparkSession, canonical_wikis: DataFrame, - anchors_file: pathlib.Path, + anchors_file: str, + model_id: str, ) -> Transformation: - spark.sparkContext.addFile(path=str(anchors_file)) + spark.sparkContext.addFile(path=anchors_file) candidate_anchors_schema = T.StructType( [ @@ -122,7 +123,9 @@ def enrich_with_candidate_anchors( ) -> Iterator[pd.DataFrame]: # Load the bloom filter containing all known anchors ahead of # processing any batches so we only load it once. - anchors = rbloom.Bloom.load(SparkFiles.get(anchors_file.name), compute_hash) + anchors = rbloom.Bloom.load( + SparkFiles.get(f"anchor_{model_id}.bloom"), compute_hash + ) for batch in sentence_batches: batch["anchor"] = [ @@ -348,7 +351,7 @@ def run( Positive example: The correct link Negative example: identified mentions and all candidate links """ - anchors_file = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" + anchors_file = "hdfs://" + str(directory / f"anchor_{model_id}.bloom") anchors_df = spark.read.parquet(str(directory / "anchors_filtered")) pageids_df = ( spark.read.parquet(str(directory / "pageids")) @@ -377,7 +380,7 @@ def run( ).cache() features_df = anchor_links_df.transform( lambda df: enrich_with_candidate_anchors( - df, spark, canonical_wikis_df, anchors_file + df, spark, canonical_wikis_df, anchors_file, model_id ) ).transform( lambda df: enrich_with_ml_features( diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index 33d079e..982f005 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "id": "f68aa58e", "metadata": {}, "outputs": [], @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "7d6412c6", "metadata": { "ExecuteTime": { @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "id": "6937bd8d", "metadata": { "ExecuteTime": { @@ -38,7 +38,16 @@ "start_time": "2025-07-17T12:36:01.276366Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -46,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 39, "id": "586923a7", "metadata": {}, "outputs": [], @@ -61,14 +70,14 @@ "# )\n", "from pyspark.sql import SparkSession\n", "\n", - "\n", + "from pyspark.sql import functions as F\n", "# from research_datasets.mwaddlink import ngram_utils, utils\n", "# from research_transformations.transformation import Transformation" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "e08b2c3c", "metadata": {}, "outputs": [ @@ -91,50 +100,52 @@ "Ivy Default Cache set to: /tmp/ivy_spark3/cache\n", "The jars for the packages stored in: /tmp/ivy_spark3/home/jars\n", "org.apache.spark#spark-avro_2.12 added as a dependency\n", - ":: resolving dependencies :: org.apache.spark#spark-submit-parent-7e6bccb6-a412-4533-85f6-8430eaf0784e;1.0\n", + ":: resolving dependencies :: org.apache.spark#spark-submit-parent-3130c1b3-8c1b-42e8-b88f-06affbdd170b;1.0\n", "\tconfs: [default]\n", "\tfound org.apache.spark#spark-avro_2.12;3.1.2 in mirrored\n", "\tfound org.spark-project.spark#unused;1.0.0 in mirrored\n", - ":: resolution report :: resolve 137ms :: artifacts dl 4ms\n", + ":: resolution report :: resolve 133ms :: artifacts dl 2ms\n", "\t---------------------------------------------------------------------\n", "\t| | modules || artifacts |\n", "\t| conf | number| search|dwnlded|evicted|| number|dwnlded|\n", "\t---------------------------------------------------------------------\n", "\t| default | 2 | 0 | 0 | 0 || 2 | 0 |\n", "\t---------------------------------------------------------------------\n", - ":: retrieving :: org.apache.spark#spark-submit-parent-7e6bccb6-a412-4533-85f6-8430eaf0784e\n", + ":: retrieving :: org.apache.spark#spark-submit-parent-3130c1b3-8c1b-42e8-b88f-06affbdd170b\n", "\tconfs: [default]\n", "\t0 artifacts copied, 2 already retrieved (0kB/4ms)\n", "Setting default log level to \"WARN\".\n", "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", - "25/07/18 09:45:18 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12000. Attempting port 12001.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12001. Attempting port 12002.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12002. Attempting port 12003.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12003. Attempting port 12004.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12004. Attempting port 12005.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12005. Attempting port 12006.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12006. Attempting port 12007.\n", - "25/07/18 09:45:18 WARN Utils: Service 'sparkDriver' could not bind on port 12007. Attempting port 12008.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4041. Attempting port 4042.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4042. Attempting port 4043.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4043. Attempting port 4044.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4044. Attempting port 4045.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4045. Attempting port 4046.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4046. Attempting port 4047.\n", - "25/07/18 09:45:19 WARN Utils: Service 'SparkUI' could not bind on port 4047. Attempting port 4048.\n", - "25/07/18 09:45:31 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar added multiple times to distributed cache.\n", - "25/07/18 09:45:31 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar added multiple times to distributed cache.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13000. Attempting port 13001.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13001. Attempting port 13002.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13002. Attempting port 13003.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13003. Attempting port 13004.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13004. Attempting port 13005.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13005. Attempting port 13006.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13006. Attempting port 13007.\n", - "25/07/18 09:45:56 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13007. Attempting port 13008.\n", - "25/07/18 09:45:56 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Attempted to request executors before the AM has registered!\n" + "25/07/30 10:09:27 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12000. Attempting port 12001.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12001. Attempting port 12002.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12002. Attempting port 12003.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12003. Attempting port 12004.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12004. Attempting port 12005.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12005. Attempting port 12006.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12006. Attempting port 12007.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12007. Attempting port 12008.\n", + "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12008. Attempting port 12009.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4041. Attempting port 4042.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4042. Attempting port 4043.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4043. Attempting port 4044.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4044. Attempting port 4045.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4045. Attempting port 4046.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4046. Attempting port 4047.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4047. Attempting port 4048.\n", + "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4048. Attempting port 4049.\n", + "25/07/30 10:09:40 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar added multiple times to distributed cache.\n", + "25/07/30 10:09:40 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar added multiple times to distributed cache.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13000. Attempting port 13001.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13001. Attempting port 13002.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13002. Attempting port 13003.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13003. Attempting port 13004.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13004. Attempting port 13005.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13005. Attempting port 13006.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13006. Attempting port 13007.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13007. Attempting port 13008.\n", + "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13008. Attempting port 13009.\n" ] } ], @@ -162,124 +173,122 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2f8892c9", "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "34375d90", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "testsetsts\n", + "wikidata_snapshot: 2025-07-14\n", + "wiki_dbs_list: ['nlwiki']\n", + "wikidata_properties_list ['P31']\n", + "directory_path /tmp/ozge2/addalink/shard_nl\n", + "2236495\n", + "2236495\n", + "\n" + ] + } + ], "source": [ - "from add_a_link import generate_anchor_dictionary" + "from click.testing import CliRunner\n", + "from add_a_link import generate_wdproperties\n", + "wikis = [\"nlwiki\"]\n", + "wikidata_properties = [\"P31\"]\n", + "hdfs_path = \"/tmp/ozge2\"\n", + "wikidata_snapshot = \"2025-07-14\"\n", + "model_id = \"shard_nl\"\n", + "runner = CliRunner()\n", + "result = runner.invoke(generate_wdproperties.main, [\n", + " \"--wikidata_snapshot\",\n", + " wikidata_snapshot,\n", + " \"--wiki_dbs\",\n", + " \",\".join(wikis),\n", + " \"--wikidata_properties\",\n", + " \",\".join(wikidata_properties),\n", + " \"--directory\",\n", + " f\"{hdfs_path}/addalink/{model_id}\",\n", + " ])\n", + "for line in result.output.split(\"\\n\"):\n", + " print(line)" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "13a242ed", + "execution_count": 43, + "id": "d1c6e043", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "spark.eventLog.enabled = true\n", - "spark.eventLog.dir = hdfs:///var/log/spark\n", - "spark.network.crypto.keyLength = 256\n", - "spark.sql.shuffle.partitions = 1000\n", - "spark.network.crypto.enabled = true\n", - "spark.sql.warehouse.dir = hdfs:///user/hive/warehouse\n", - "spark.network.crypto.keyFactoryAlgorithm = PBKDF2WithHmacSHA256\n", - "spark.pyspark.driver.python = python\n", - "spark.sql.catalog.spark_catalog = org.apache.iceberg.spark.SparkSessionCatalog\n", - "spark.driver.blockManager.port = 13000\n", - "spark.yarn.appMasterEnv.REQUESTS_CA_BUNDLE = /etc/ssl/certs/ca-certificates.crt\n", - "spark.yarn.archive = hdfs:///user/spark/share/lib/spark-3.1.2-assembly.jar\n", - "spark.network.timeout = 1200s\n", - "spark.pyspark.python = ./env/bin/python\n", - "spark.org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter.param.PROXY_HOSTS = an-master1003.eqiad.wmnet,an-master1004.eqiad.wmnet\n", - "spark.jars.packages = org.apache.spark:spark-avro_2.12:3.1.2\n", - "spark.executorEnv.PYTHONPATH = /etc/jupyterhub-conda{{PWD}}/pyspark.zip{{PWD}}/py4j-0.10.9-src.zip{{PWD}}/org.apache.spark_spark-avro_2.12-3.1.2.jar{{PWD}}/org.spark-project.spark_unused-1.0.0.jar\n", - "spark.shuffle.io.maxRetries = 10\n", - "spark.local.dir = /srv/spark-tmp\n", - "spark.ui.filters = org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter\n", - "spark.sql.execution.arrow.pyspark.enabled = true\n", - "spark.executor.defaultJavaOptions = -Djava.net.useSystemProxies=True\n", - "spark.app.name = interactive\n", - "spark.org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter.param.PROXY_URI_BASES = http://an-master1003.eqiad.wmnet:8088/proxy/application_1750705250302_776086,http://an-master1004.eqiad.wmnet:8088/proxy/application_1750705250302_776086\n", - "spark.executor.id = driver\n", - "spark.yarn.dist.archives = https://gitlab.wikimedia.org/api/v4/projects/3455/packages/generic/add_a_link/0.1.1/add_a_link-0.1.1.conda.tgz#env\n", - "spark.sql.extensions = org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions\n", - "spark.driver.appUIAddress = http://stat1010.eqiad.wmnet:4048\n", - "spark.executor.memory = 32g\n", - "spark.driver.maxResultSize = 40G\n", - "spark.sql.catalogImplementation = hive\n", - "spark.driver.host = stat1010.eqiad.wmnet\n", - "spark.dynamicAllocation.cachedExecutorIdleTimeout = 3600s\n", - "spark.network.crypto.saslFallback = false\n", - "spark.shuffle.io.retryWait = 1200s\n", - "spark.driver.port = 12008\n", - "spark.authenticate = true\n", - "spark.executor.memoryOverhead = 4g\n", - "spark.port.maxRetries = 100\n", - "spark.driver.extraJavaOptions = -Divy.cache.dir=/tmp/ivy_spark3/cache -Divy.home=/tmp/ivy_spark3/home \n", - "spark.app.id = application_1750705250302_776086\n", - "spark.dynamicAllocation.maxExecutors = 119\n", - "spark.driver.defaultJavaOptions = -Djava.net.useSystemProxies=True\n", - "spark.repl.local.jars = file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar,file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar\n", - "spark.submit.pyFiles = /tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar,/tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar\n", - "spark.ui.port = 4040\n", - "spark.executor.cores = 4\n", - "spark.yarn.dist.pyFiles = file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar,file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar\n", - "spark.sql.files.maxPartitionBytes = 268435456\n", - "spark.executorEnv.REQUESTS_CA_BUNDLE = /etc/ssl/certs/ca-certificates.crt\n", - "spark.serializer.objectStreamReset = 100\n", - "spark.dynamicAllocation.executorIdleTimeout = 60s\n", - "spark.submit.deployMode = client\n", - "spark.app.startTime = 1752831918368\n", - "spark.yarn.secondary.jars = org.apache.spark_spark-avro_2.12-3.1.2.jar,org.spark-project.spark_unused-1.0.0.jar\n", - "spark.yarn.dist.jars = file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar,file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar\n", - "spark.shuffle.service.enabled = true\n", - "spark.executorEnv.LD_LIBRARY_PATH = /usr/lib/hadoop/lib/native\n", - "spark.sql.adaptive.enabled = true\n", - "spark.jars.ivySettings = /etc/maven/ivysettings.xml\n", - "spark.yarn.historyServer.address = yarn.wikimedia.org\n", - "spark.org.apache.hadoop.yarn.server.webproxy.amfilter.AmIpFilter.param.RM_HA_URLS = an-master1003.eqiad.wmnet:8088,an-master1004.eqiad.wmnet:8088\n", - "spark.master = yarn\n", - "spark.rdd.compress = True\n", - "spark.eventLog.compress = true\n", - "spark.yarn.isPython = true\n", - "spark.dynamicAllocation.enabled = true\n", - "spark.driver.memory = 32G\n", - "spark.ui.proxyBase = /proxy/application_1750705250302_776086\n", - "spark.sql.catalog.spark_catalog.type = hive\n", - "spark.ui.showConsoleProgress = true\n" + " \r" ] }, { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[12], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m model_id \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrwiki\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3\u001b[0m output \u001b[38;5;241m=\u001b[39m pathlib\u001b[38;5;241m.\u001b[39mPath(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/user/ozge/test_addalink_ml/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 4\u001b[0m \u001b[43mgenerate_anchor_dictionary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mspark\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[43mmodel_id\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mshard_1\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/srv/home/ozge/repos/wiki/gitlab/ozge/ml-pipelines/add_a_link/src/add_a_link/generate_anchor_dictionary.py:460\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(spark, wiki_dbs, output, model_id)\u001b[0m\n\u001b[1;32m 442\u001b[0m revision_content_col \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mcol(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrevision_content_slots\u001b[39m\u001b[38;5;124m\"\u001b[39m)[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmain\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcontent_body\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 443\u001b[0m mediawiki_wikitext_current \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 444\u001b[0m spark\u001b[38;5;241m.\u001b[39mtable(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwmf_content.mediawiki_content_current_v1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 445\u001b[0m \u001b[38;5;241m.\u001b[39mwithColumn(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrevision_text\u001b[39m\u001b[38;5;124m\"\u001b[39m, revision_content_col)\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 452\u001b[0m \u001b[38;5;241m.\u001b[39mwithColumnRenamed(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpage_redirect_target\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpage_redirect_title\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 453\u001b[0m )\n\u001b[1;32m 455\u001b[0m (\n\u001b[1;32m 456\u001b[0m \u001b[43mmediawiki_wikitext_current\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtransform\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 457\u001b[0m \u001b[43m \u001b[49m\u001b[43menrich_with_articles\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwiki_dbs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 458\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 459\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moverwrite\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m--> 460\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparquet\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43moutput\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpageids\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 461\u001b[0m )\n\u001b[1;32m 463\u001b[0m (\n\u001b[1;32m 464\u001b[0m mediawiki_wikitext_current\u001b[38;5;241m.\u001b[39mtransform(\n\u001b[1;32m 465\u001b[0m enrich_with_redirects(wiki_dbs),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 468\u001b[0m \u001b[38;5;241m.\u001b[39mparquet(\u001b[38;5;28mstr\u001b[39m(output \u001b[38;5;241m/\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mredirects\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m 469\u001b[0m )\n\u001b[1;32m 471\u001b[0m (\n\u001b[1;32m 472\u001b[0m mediawiki_wikitext_current\u001b[38;5;241m.\u001b[39mtransform(\n\u001b[1;32m 473\u001b[0m enrich_with_anchors(spark\u001b[38;5;241m=\u001b[39mspark, wiki_dbs\u001b[38;5;241m=\u001b[39mwiki_dbs, model_id\u001b[38;5;241m=\u001b[39mmodel_id),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 476\u001b[0m \u001b[38;5;241m.\u001b[39mparquet(\u001b[38;5;28mstr\u001b[39m(output \u001b[38;5;241m/\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124manchors\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m 477\u001b[0m )\n", - "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyspark/sql/readwriter.py:1250\u001b[0m, in \u001b[0;36mDataFrameWriter.parquet\u001b[0;34m(self, path, mode, partitionBy, compression)\u001b[0m\n\u001b[1;32m 1248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpartitionBy(partitionBy)\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_opts(compression\u001b[38;5;241m=\u001b[39mcompression)\n\u001b[0;32m-> 1250\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_jwrite\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparquet\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/py4j/java_gateway.py:1303\u001b[0m, in \u001b[0;36mJavaMember.__call__\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 1296\u001b[0m args_command, temp_args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_build_args(\u001b[38;5;241m*\u001b[39margs)\n\u001b[1;32m 1298\u001b[0m command \u001b[38;5;241m=\u001b[39m proto\u001b[38;5;241m.\u001b[39mCALL_COMMAND_NAME \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1299\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommand_header \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1300\u001b[0m args_command \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1301\u001b[0m proto\u001b[38;5;241m.\u001b[39mEND_COMMAND_PART\n\u001b[0;32m-> 1303\u001b[0m answer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgateway_client\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend_command\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1304\u001b[0m return_value \u001b[38;5;241m=\u001b[39m get_return_value(\n\u001b[1;32m 1305\u001b[0m answer, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgateway_client, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtarget_id, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mname)\n\u001b[1;32m 1307\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m temp_arg \u001b[38;5;129;01min\u001b[39;00m temp_args:\n", - "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/py4j/java_gateway.py:1033\u001b[0m, in \u001b[0;36mGatewayClient.send_command\u001b[0;34m(self, command, retry, binary)\u001b[0m\n\u001b[1;32m 1031\u001b[0m connection \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_connection()\n\u001b[1;32m 1032\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1033\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconnection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend_command\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1034\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m binary:\n\u001b[1;32m 1035\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m response, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_create_connection_guard(connection)\n", - "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/py4j/java_gateway.py:1200\u001b[0m, in \u001b[0;36mGatewayConnection.send_command\u001b[0;34m(self, command)\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m Py4JNetworkError(\n\u001b[1;32m 1197\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mError while sending\u001b[39m\u001b[38;5;124m\"\u001b[39m, e, proto\u001b[38;5;241m.\u001b[39mERROR_ON_SEND)\n\u001b[1;32m 1199\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1200\u001b[0m answer \u001b[38;5;241m=\u001b[39m smart_decode(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstream\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreadline\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m[:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 1201\u001b[0m logger\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAnswer received: \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(answer))\n\u001b[1;32m 1202\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m answer\u001b[38;5;241m.\u001b[39mstartswith(proto\u001b[38;5;241m.\u001b[39mRETURN_MESSAGE):\n", - "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/socket.py:717\u001b[0m, in \u001b[0;36mSocketIO.readinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m 715\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m 716\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 717\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrecv_into\u001b[49m\u001b[43m(\u001b[49m\u001b[43mb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 718\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m timeout:\n\u001b[1;32m 719\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_timeout_occurred \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "data": { + "text/plain": [ + "[Row(max(snapshot)='2025-06')]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_table = spark.read.table(\"research.article_topics\")\n", + "df_table.select(F.max(\"snapshot\")).collect()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5821e769", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 items\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 10:20 /tmp/ozge2/addalink/shard_nl/wdproperties\n" ] } ], "source": [ - "model_id = \"trwiki\"\n", - "output = pathlib.Path(f\"/user/ozge/test_addalink_ml/{model_id}\")\n", - "generate_anchor_dictionary.run(spark, [model_id], output, \"shard_1\")" + "!hdfs dfs -ls /tmp/ozge2/addalink/shard_nl" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, + "id": "2ef9cc28", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 16, "id": "99e21fd9", "metadata": {}, "outputs": [ @@ -294,7 +303,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "479071\n" + "0\n" ] }, { @@ -326,68 +335,28 @@ " \n", " \n", " wiki_db\n", - " anchor\n", - " link_occurrence\n", + " page_id\n", + " statement_value_qid\n", " \n", " \n", " \n", - " \n", - " 0\n", - " trwiki\n", - " \"angel\" (mika newton şarkısı)\n", - " {'Angel (Mika Newton şarkısı)': 2}\n", - " \n", - " \n", - " 1\n", - " trwiki\n", - " \"das reich\" tümeni\n", - " {'2. Waffen-SS Panzer Tümeni Das Reich': 2}\n", - " \n", - " \n", - " 2\n", - " trwiki\n", - " \"hangman\" adam page\n", - " {'Adam Page': 3}\n", - " \n", - " \n", - " 3\n", - " trwiki\n", - " \"i'll be there for you\"\n", - " {'I'll Be There for You (The Rembrandts şarkıs...\n", - " \n", - " \n", - " 4\n", - " trwiki\n", - " \"leningrad'ın savunmasına göre\" madalyası\n", - " {'Leningrad Savunması Madalyası': 2}\n", - " \n", " \n", "\n", "" ], "text/plain": [ - " wiki_db anchor \\\n", - "0 trwiki \"angel\" (mika newton şarkısı) \n", - "1 trwiki \"das reich\" tümeni \n", - "2 trwiki \"hangman\" adam page \n", - "3 trwiki \"i'll be there for you\" \n", - "4 trwiki \"leningrad'ın savunmasına göre\" madalyası \n", - "\n", - " link_occurrence \n", - "0 {'Angel (Mika Newton şarkısı)': 2} \n", - "1 {'2. Waffen-SS Panzer Tümeni Das Reich': 2} \n", - "2 {'Adam Page': 3} \n", - "3 {'I'll Be There for You (The Rembrandts şarkıs... \n", - "4 {'Leningrad Savunması Madalyası': 2} " + "Empty DataFrame\n", + "Columns: [wiki_db, page_id, statement_value_qid]\n", + "Index: []" ] }, - "execution_count": 8, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_anchors = spark.read.parquet(\"/user/ozge/test_addalink_ml/trwiki/anchors\")\n", + "df_anchors = spark.read.parquet(\"/tmp/ozge2/addalink/shard_nl/wdproperties\")\n", "print(df_anchors.count())\n", "df_anchors.limit(5).toPandas()" ] diff --git a/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb b/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb new file mode 100644 index 0000000..7f78ea8 --- /dev/null +++ b/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f68aa58e", + "metadata": {}, + "outputs": [], + "source": [ + "!export LD_LIBRARY_PATH=\"$CONDA_PREFIX/lib\"\n", + "\n", + "!export HADOOP_CONF_DIR=\"/etc/hadoop/conf\"\n", + "!export HADOOP_HOME=\"/usr/lib/hadoop\"\n", + "!export JAVA_HOME=$(dirname $(dirname $(readlink -f $(which javac))))\n", + "!export CLASSPATH=$CLASSPATH:`hadoop classpath --glob`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6937bd8d", + "metadata": { + "ExecuteTime": { + "end_time": "2025-07-17T12:36:01.288104Z", + "start_time": "2025-07-17T12:36:01.276366Z" + } + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "586923a7", + "metadata": {}, + "outputs": [], + "source": [ + "import pathlib\n", + "from pyspark.sql import SparkSession\n", + "import rbloom" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e08b2c3c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SPARK_HOME: /usr/lib/spark3/\n", + "Using Hadoop client lib jars at 3.2.0, provided by Spark.\n", + "PYSPARK_DRIVER_PYTHON=python\n", + "PYSPARK_PYTHON=./env/bin/python\n", + ":: loading settings :: file = /etc/maven/ivysettings.xml\n", + ":: loading settings :: url = jar:file:/opt/conda-analytics/lib/python3.10/site-packages/pyspark/jars/ivy-2.4.0.jar!/org/apache/ivy/core/settings/ivysettings.xml\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Ivy Default Cache set to: /tmp/ivy_spark3/cache\n", + "The jars for the packages stored in: /tmp/ivy_spark3/home/jars\n", + "org.apache.spark#spark-avro_2.12 added as a dependency\n", + ":: resolving dependencies :: org.apache.spark#spark-submit-parent-df53ef43-bbba-4195-91b2-37929835f0d1;1.0\n", + "\tconfs: [default]\n", + "\tfound org.apache.spark#spark-avro_2.12;3.1.2 in mirrored\n", + "\tfound org.spark-project.spark#unused;1.0.0 in mirrored\n", + ":: resolution report :: resolve 139ms :: artifacts dl 2ms\n", + "\t---------------------------------------------------------------------\n", + "\t| | modules || artifacts |\n", + "\t| conf | number| search|dwnlded|evicted|| number|dwnlded|\n", + "\t---------------------------------------------------------------------\n", + "\t| default | 2 | 0 | 0 | 0 || 2 | 0 |\n", + "\t---------------------------------------------------------------------\n", + ":: retrieving :: org.apache.spark#spark-submit-parent-df53ef43-bbba-4195-91b2-37929835f0d1\n", + "\tconfs: [default]\n", + "\t0 artifacts copied, 2 already retrieved (0kB/4ms)\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", + "25/07/30 11:20:19 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12000. Attempting port 12001.\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12001. Attempting port 12002.\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12002. Attempting port 12003.\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12003. Attempting port 12004.\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12004. Attempting port 12005.\n", + "25/07/30 11:20:19 WARN Utils: Service 'sparkDriver' could not bind on port 12005. Attempting port 12006.\n", + "25/07/30 11:20:20 WARN Utils: Service 'sparkDriver' could not bind on port 12006. Attempting port 12007.\n", + "25/07/30 11:20:20 WARN Utils: Service 'sparkDriver' could not bind on port 12007. Attempting port 12008.\n", + "25/07/30 11:20:20 WARN Utils: Service 'sparkDriver' could not bind on port 12008. Attempting port 12009.\n", + "25/07/30 11:20:20 WARN Utils: Service 'sparkDriver' could not bind on port 12009. Attempting port 12010.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4041. Attempting port 4042.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4042. Attempting port 4043.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4043. Attempting port 4044.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4044. Attempting port 4045.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4045. Attempting port 4046.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4046. Attempting port 4047.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4047. Attempting port 4048.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4048. Attempting port 4049.\n", + "25/07/30 11:20:20 WARN Utils: Service 'SparkUI' could not bind on port 4049. Attempting port 4050.\n", + "25/07/30 11:20:32 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar added multiple times to distributed cache.\n", + "25/07/30 11:20:32 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar added multiple times to distributed cache.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13000. Attempting port 13001.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13001. Attempting port 13002.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13002. Attempting port 13003.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13003. Attempting port 13004.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13004. Attempting port 13005.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13005. Attempting port 13006.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13006. Attempting port 13007.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13007. Attempting port 13008.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13008. Attempting port 13009.\n", + "25/07/30 11:21:01 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13009. Attempting port 13010.\n" + ] + } + ], + "source": [ + "from research_common.spark import create_yarn_spark_session\n", + "\n", + "# spark.stop()\n", + "spark = create_yarn_spark_session(\n", + " app_id=\"interactive\",\n", + " gitlab_project=\"ozge/ml-pipelines\",\n", + " extra_config={\n", + " \"spark.dynamicAllocation.maxExecutors\": 119,\n", + " \"spark.executor.cores\": 4,\n", + " \"spark.sql.adaptive.enabled\": \"true\",\n", + " \"spark.sql.shuffle.partitions\": 1000,\n", + " \"spark.driver.memory\": \"32G\",\n", + " \"spark.driver.maxResultSize\": \"40G\",\n", + " \"spark.executor.memory\": \"32g\",\n", + " \"spark.executor.memoryOverhead\": \"4g\",\n", + " \"spark.network.timeout\": \"1200s\",\n", + " \"spark.shuffle.io.retryWait\": \"1200s\",\n", + " },\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2f8892c9", + "metadata": {}, + "outputs": [], + "source": [ + "import hashlib\n", + "import pickle\n", + "from typing import Any\n", + "items = [\"a\", \"b\", \"d\"]\n", + "model_id = \"shard_example\"\n", + "output_path = pathlib.Path.cwd() / f\"anchor_{model_id}.bloom\"\n", + "def compute_hash(obj: Any) -> int:\n", + " obj_hash = hashlib.sha256(pickle.dumps(obj), usedforsecurity=False).digest()\n", + " return int.from_bytes(obj_hash[:16], \"big\") - 2**127\n", + "\n", + "bf = rbloom.Bloom(\n", + " expected_items=1000,\n", + " false_positive_rate=0.01,\n", + " hash_func=compute_hash,\n", + " )\n", + "bf.update(items)\n", + "bf.save(output_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "54fc422a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/srv/home/ozge/anchor_shard_example.bloom\n" + ] + } + ], + "source": [ + "! ls /srv/home/ozge/anchor_shard_example.bloom" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "13a242ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CompletedProcess(args=['hdfs', 'dfs', '-put', '/srv/home/ozge/anchor_shard_example.bloom', '/user/ozge/temp/anchor_shard_example.bloom'], returncode=0, stdout='', stderr='')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import subprocess\n", + "\n", + "hdfs_path = f\"/user/ozge/temp/anchor_{model_id}.bloom\"\n", + "subprocess.run([\"hdfs\", \"dfs\", \"-rm\", \"-f\", hdfs_path],check=True, capture_output=True, text=True)\n", + "subprocess.run([\n", + " 'hdfs', 'dfs', '-put', str(output_path), hdfs_path],check=True, capture_output=True, text=True\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d5aab157", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 items\n", + "-rw-r----- 3 ozge ozge 1207 2025-07-30 11:28 /user/ozge/temp/anchor_shard_example.bloom\n" + ] + } + ], + "source": [ + "!hdfs dfs -ls /user/ozge/temp" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "46eca8cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "put: `/user/ozge/test_addalink_bloom/anchor_shard_example.bloom': No such file or directory: `hdfs://analytics-hadoop/user/ozge/test_addalink_bloom/anchor_shard_example.bloom'\n" + ] + } + ], + "source": [ + "! hdfs dfs -put /srv/home/ozge/anchor_shard_example.bloom /user/ozge/test_addalink_bloom/anchor_shard_example.bloom" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9c4b801b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 items\n", + "-rw-r----- 3 ozge ozge 1207 2025-07-23 08:57 /user/ozge/temp/anchor_shard_example.bloom\n" + ] + } + ], + "source": [ + "!hdfs dfs -ls /user/ozge/temp" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "f1e3d2d5", + "metadata": {}, + "outputs": [], + "source": [ + "from pyspark.files import SparkFiles\n", + "\n", + "read_hdfs_path = f\"hdfs:///user/ozge/temp/anchor_{model_id}.bloom\"\n", + "spark.sparkContext.addFile(read_hdfs_path)\n", + "\n", + "bloom_file = rbloom.Bloom.load(SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "9ed66b98", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"aa\" in bloom_file" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "f47fa945", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hdfs:///tmp/ozge/addalink/shard_example/anchor_shard_example.bloom'" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdfs_path = \"/tmp/ozge\"\n", + "directory = f\"{hdfs_path}/addalink/{model_id}\"\n", + "directory = pathlib.Path(directory)\n", + "\"hdfs://\" + str(directory / f\"anchor_{model_id}.bloom\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "8a07680e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'hdfs:///user/ozge/temp/anchor_shard_example.bloom'" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "read_hdfs_path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b70b642", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "add_a_link_remote", + "language": "python", + "name": "add_a_link_remote" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} -- GitLab From 0316f3ccfa83227c409e1107c3d5901621d4059c Mon Sep 17 00:00:00 2001 From: ozge Date: Wed, 30 Jul 2025 17:47:36 +0200 Subject: [PATCH 06/13] feat: adds addalink steps --- .../add_a_link/generate_anchor_dictionary.py | 2 +- .../src/add_a_link/generate_training_data.py | 2 +- .../add_a_link/notebooks/pipeline_run.ipynb | 34665 +++++++++++++++- .../add_a_link/notebooks/rbloom_example.ipynb | 45 +- 4 files changed, 34600 insertions(+), 114 deletions(-) diff --git a/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py b/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py index 3679ffd..a739fad 100644 --- a/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py +++ b/training/add_a_link/src/add_a_link/generate_anchor_dictionary.py @@ -479,7 +479,7 @@ def run( text=True, ) subprocess.run( - ["hdfs", "dfs", "-put", str(anchors_hdfs_path), anchors_hdfs_path], + ["hdfs", "dfs", "-put", str(anchors_path), anchors_hdfs_path], check=True, capture_output=True, text=True, diff --git a/training/add_a_link/src/add_a_link/generate_training_data.py b/training/add_a_link/src/add_a_link/generate_training_data.py index aa362b4..4f1c0b2 100644 --- a/training/add_a_link/src/add_a_link/generate_training_data.py +++ b/training/add_a_link/src/add_a_link/generate_training_data.py @@ -108,7 +108,7 @@ def enrich_with_candidate_anchors( anchors_file: str, model_id: str, ) -> Transformation: - spark.sparkContext.addFile(path=anchors_file) + spark.sparkContext.addFile(str(pathlib.Path.cwd() / f"anchor_{model_id}.bloom")) candidate_anchors_schema = T.StructType( [ diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index 982f005..fa89c3e 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 18, + "execution_count": 1, "id": "f68aa58e", "metadata": {}, "outputs": [], @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "id": "6937bd8d", "metadata": { "ExecuteTime": { @@ -38,16 +38,7 @@ "start_time": "2025-07-17T12:36:01.276366Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2" @@ -55,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "id": "586923a7", "metadata": {}, "outputs": [], @@ -72,87 +63,79 @@ "\n", "from pyspark.sql import functions as F\n", "# from research_datasets.mwaddlink import ngram_utils, utils\n", - "# from research_transformations.transformation import Transformation" + "# from research_transformations.transformation import Transformation\n", + "import pathlib\n", + "from pyspark.sql import SparkSession\n", + "import rbloom\n", + "from pyspark.files import SparkFiles\n", + "from add_a_link.generate_anchor_dictionary import (\n", + " ParsedLink,\n", + " compute_hash,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 52, "id": "e08b2c3c", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SPARK_HOME: /usr/lib/spark3/\n", - "Using Hadoop client lib jars at 3.2.0, provided by Spark.\n", - "PYSPARK_DRIVER_PYTHON=python\n", - "PYSPARK_PYTHON=./env/bin/python\n", - ":: loading settings :: file = /etc/maven/ivysettings.xml\n", - ":: loading settings :: url = jar:file:/opt/conda-analytics/lib/python3.10/site-packages/pyspark/jars/ivy-2.4.0.jar!/org/apache/ivy/core/settings/ivysettings.xml\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "Ivy Default Cache set to: /tmp/ivy_spark3/cache\n", - "The jars for the packages stored in: /tmp/ivy_spark3/home/jars\n", - "org.apache.spark#spark-avro_2.12 added as a dependency\n", - ":: resolving dependencies :: org.apache.spark#spark-submit-parent-3130c1b3-8c1b-42e8-b88f-06affbdd170b;1.0\n", - "\tconfs: [default]\n", - "\tfound org.apache.spark#spark-avro_2.12;3.1.2 in mirrored\n", - "\tfound org.spark-project.spark#unused;1.0.0 in mirrored\n", - ":: resolution report :: resolve 133ms :: artifacts dl 2ms\n", - "\t---------------------------------------------------------------------\n", - "\t| | modules || artifacts |\n", - "\t| conf | number| search|dwnlded|evicted|| number|dwnlded|\n", - "\t---------------------------------------------------------------------\n", - "\t| default | 2 | 0 | 0 | 0 || 2 | 0 |\n", - "\t---------------------------------------------------------------------\n", - ":: retrieving :: org.apache.spark#spark-submit-parent-3130c1b3-8c1b-42e8-b88f-06affbdd170b\n", - "\tconfs: [default]\n", - "\t0 artifacts copied, 2 already retrieved (0kB/4ms)\n", - "Setting default log level to \"WARN\".\n", - "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", - "25/07/30 10:09:27 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12000. Attempting port 12001.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12001. Attempting port 12002.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12002. Attempting port 12003.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12003. Attempting port 12004.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12004. Attempting port 12005.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12005. Attempting port 12006.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12006. Attempting port 12007.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12007. Attempting port 12008.\n", - "25/07/30 10:09:28 WARN Utils: Service 'sparkDriver' could not bind on port 12008. Attempting port 12009.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4041. Attempting port 4042.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4042. Attempting port 4043.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4043. Attempting port 4044.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4044. Attempting port 4045.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4045. Attempting port 4046.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4046. Attempting port 4047.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4047. Attempting port 4048.\n", - "25/07/30 10:09:28 WARN Utils: Service 'SparkUI' could not bind on port 4048. Attempting port 4049.\n", - "25/07/30 10:09:40 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar added multiple times to distributed cache.\n", - "25/07/30 10:09:40 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar added multiple times to distributed cache.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13000. Attempting port 13001.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13001. Attempting port 13002.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13002. Attempting port 13003.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13003. Attempting port 13004.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13004. Attempting port 13005.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13005. Attempting port 13006.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13006. Attempting port 13007.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13007. Attempting port 13008.\n", - "25/07/30 10:10:04 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13008. Attempting port 13009.\n" + "25/07/30 15:06:03 ERROR FileFormatWriter: Aborting job b59fb202-0469-4a70-88a3-4ed0a1ca704b.\n", + "org.apache.spark.SparkException: Job 124 cancelled because SparkContext was shut down\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$cleanUpAfterSchedulerStop$1(DAGScheduler.scala:1085)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$cleanUpAfterSchedulerStop$1$adapted(DAGScheduler.scala:1083)\n", + "\tat scala.collection.mutable.HashSet.foreach(HashSet.scala:79)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.cleanUpAfterSchedulerStop(DAGScheduler.scala:1083)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onStop(DAGScheduler.scala:2463)\n", + "\tat org.apache.spark.util.EventLoop.stop(EventLoop.scala:84)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.stop(DAGScheduler.scala:2369)\n", + "\tat org.apache.spark.SparkContext.$anonfun$stop$12(SparkContext.scala:2069)\n", + "\tat org.apache.spark.util.Utils$.tryLogNonFatalError(Utils.scala:1419)\n", + "\tat org.apache.spark.SparkContext.stop(SparkContext.scala:2069)\n", + "\tat org.apache.spark.api.java.JavaSparkContext.stop(JavaSparkContext.scala:550)\n", + "\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n", + "\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\n", + "\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n", + "\tat java.lang.reflect.Method.invoke(Method.java:498)\n", + "\tat py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:244)\n", + "\tat py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:357)\n", + "\tat py4j.Gateway.invoke(Gateway.java:282)\n", + "\tat py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)\n", + "\tat py4j.commands.CallCommand.execute(CallCommand.java:79)\n", + "\tat py4j.GatewayConnection.run(GatewayConnection.java:238)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "25/07/30 15:06:04 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n", + "25/07/30 15:06:04 WARN Utils: Service 'sparkDriver' could not bind on port 12000. Attempting port 12001.\n", + "25/07/30 15:06:04 WARN Utils: Service 'sparkDriver' could not bind on port 12001. Attempting port 12002.\n", + "25/07/30 15:06:04 WARN Utils: Service 'sparkDriver' could not bind on port 12002. Attempting port 12003.\n", + "25/07/30 15:06:04 WARN Utils: Service 'SparkUI' could not bind on port 4040. Attempting port 4041.\n", + "25/07/30 15:06:04 WARN Utils: Service 'SparkUI' could not bind on port 4041. Attempting port 4042.\n", + "25/07/30 15:06:04 WARN Utils: Service 'SparkUI' could not bind on port 4042. Attempting port 4043.\n", + "25/07/30 15:06:13 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.apache.spark_spark-avro_2.12-3.1.2.jar added multiple times to distributed cache.\n", + "25/07/30 15:06:13 WARN Client: Same path resource file:///tmp/ivy_spark3/home/jars/org.spark-project.spark_unused-1.0.0.jar added multiple times to distributed cache.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13000. Attempting port 13001.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13001. Attempting port 13002.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13002. Attempting port 13003.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13003. Attempting port 13004.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13004. Attempting port 13005.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13005. Attempting port 13006.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13006. Attempting port 13007.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13007. Attempting port 13008.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13008. Attempting port 13009.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13009. Attempting port 13010.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13010. Attempting port 13011.\n", + "25/07/30 15:06:35 WARN Utils: Service 'org.apache.spark.network.netty.NettyBlockTransferService' could not bind on port 13011. Attempting port 13012.\n" ] } ], "source": [ "from research_common.spark import create_yarn_spark_session\n", "\n", - "# spark.stop()\n", + "spark.stop()\n", "spark = create_yarn_spark_session(\n", " app_id=\"interactive\",\n", " gitlab_project=\"ozge/ml-pipelines\",\n", @@ -173,11 +156,33360 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "id": "2f8892c9", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:06:52 WARN YarnScheduler: Initial job has not accepted any resources; check your cluster UI to ensure that workers are registered and have sufficient resources\n", + "25/07/30 15:07:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "org.apache.spark.SparkException: EOF reached before Python server acknowledged\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:736)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:33 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:33 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:34 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:34 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:34 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:34 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:34 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:41 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:41 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:52 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:52 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:52 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:52 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:52 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:53 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:54 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:54 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:55 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:58 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:58 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:58 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:07:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:16 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:17 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:17 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:21 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:37 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:38 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:38 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:38 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:38 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:41 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:41 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:42 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:43 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:48 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:50 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:51 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:08:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:00 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:02 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:03 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:09 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:10 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:11 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:12 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:13 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:14 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:15 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:18 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 125\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 112\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 122\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 115\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 119\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 116\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 120\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 121\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 117\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 113\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 114\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 123\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 118\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:20 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 124\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:22 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 114\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 115\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 121\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 123\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 124\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 129\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 130\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 116\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 134\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 126\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 160\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 139\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 122\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 127\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 135\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 132\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 138\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 143\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 125\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 142\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 145\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 137\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 131\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 141\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 140\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 156\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 128\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 133\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 149\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 136\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 148\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 158\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 155\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 154\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 147\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 144\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 157\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 150\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 153\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 152\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 117\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 114\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 116\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 112\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 113\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 129\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 130\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 137\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 146\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 132\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 143\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 127\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 151\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 134\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 136\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 135\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 115\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 148\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 123\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 147\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 118\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 152\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 119\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 139\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 122\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 159\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 156\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 151\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 149\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 138\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 140\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 157\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 154\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 126\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 145\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 146\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 141\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 150\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 125\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 160\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 124\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 142\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 167\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 153\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 161\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 163\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 158\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 162\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 155\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 165\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 164\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 144\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 166\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 159\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 168\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 128\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 120\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 121\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 131\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 133\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:25 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 118\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 120\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 117\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 112\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 119\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 113\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 129\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 118\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 112\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 124\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 130\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 127\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 123\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 114\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 121\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 126\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 122\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 131\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 179\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 115\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 128\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 119\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 132\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 138\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 139\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 136\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 137\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 134\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 143\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 146\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 165\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 172\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 141\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 140\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 148\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 150\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 133\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 144\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 142\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 154\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 149\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 157\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 158\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 161\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 155\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 163\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 152\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 169\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 116\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 135\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 164\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 166\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 151\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 113\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 159\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 156\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 120\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 160\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 153\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 167\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 145\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 147\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 162\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 168\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 170\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 174\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 176\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 171\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 175\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 173\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 178\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 177\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 125\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 117\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 99\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 69\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 64\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 92\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 57\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 108\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 60\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 38\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 95\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 119\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 129\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 76\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 53\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 36\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 48\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 85\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 41\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 112\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 79\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 87\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 50\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 89\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 74\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 116\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 106\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 107\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 63\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 52\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 35\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 98\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 75\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 128\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 73\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 37\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 103\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 70\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 71\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 61\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 55\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 86\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 115\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 49\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 43\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 122\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 90\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 81\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 130\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 77\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 39\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 96\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 117\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 109\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 42\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 114\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 125\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 45\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 67\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 120\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 80\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 111\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 127\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 102\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 126\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 56\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 124\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 83\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 72\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 105\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 62\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 82\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 34\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 104\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 68\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 66\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 100\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 97\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 47\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 121\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 44\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 113\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 101\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 65\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 123\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 84\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 54\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 46\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 132\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 59\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 51\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 94\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 88\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 78\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 110\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 131\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 91\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 118\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 93\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 133\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 138\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 40\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 137\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 134\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 58\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 136\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 135\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 157\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 140\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 142\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 150\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 153\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 139\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 145\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 143\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 166\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 151\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 148\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 149\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 152\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 159\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 154\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 155\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 160\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 164\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 141\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 156\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 158\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 146\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 165\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 147\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 163\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 162\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 144\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 161\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:09:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:14:59 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:15:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:16:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:16:38 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:16:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:16:45 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:16:49 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:17:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:17:35 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:17:42 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:17:57 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:18:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:18:40 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:18:44 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:19:05 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:19:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:19:36 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:19:47 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:19:56 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:20:04 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:20:06 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:20:08 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:20:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:20:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:21:01 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:21:39 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:21:54 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:23:46 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:24:07 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:24:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:19 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1593)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 1\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 3\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 7\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:23 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 5\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 0\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 4\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 2\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:24 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 6\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 8\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 10\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:26 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 11\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 9\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:27 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 12\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 14\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 13\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:28 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 15\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 20\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 21\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:29 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 24\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 22\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 23\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 26\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 25\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:30 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 27\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:31 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 33\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 30\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 18\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 19\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 16\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 17\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:32 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 28\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:33 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 29\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:33 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 31\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "25/07/30 15:25:33 ERROR DAGScheduler: Failed to update accumulator 25784 (org.apache.spark.api.python.PythonAccumulatorV2) for task 32\n", + "java.net.SocketException: Broken pipe (Write failed)\n", + "\tat java.net.SocketOutputStream.socketWrite0(Native Method)\n", + "\tat java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)\n", + "\tat java.net.SocketOutputStream.write(SocketOutputStream.java:155)\n", + "\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n", + "\tat java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)\n", + "\tat java.io.DataOutputStream.flush(DataOutputStream.java:123)\n", + "\tat org.apache.spark.api.python.PythonAccumulatorV2.merge(PythonRDD.scala:732)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1(DAGScheduler.scala:1485)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$updateAccumulators$1$adapted(DAGScheduler.scala:1476)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.updateAccumulators(DAGScheduler.scala:1476)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskCompletion(DAGScheduler.scala:1588)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2442)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + " \r" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from click.testing import CliRunner\n", + "from add_a_link import generate_anchor_dictionary\n", + "wikis = [\"nlwiki\"]\n", + "wikidata_properties = [\"P31\"]\n", + "hdfs_path = \"/tmp/ozge\"\n", + "wikidata_snapshot = \"2025-07-14\"\n", + "model_id = \"shard_nl\"\n", + "runner = CliRunner()\n", + "result = runner.invoke(generate_anchor_dictionary.main, [\n", + " \"--wiki_dbs\",\n", + " \",\".join(wikis),\n", + " \"--output\",\n", + " f\"{hdfs_path}/addalink/{model_id}\",\n", + " \"--model_id\",\n", + " model_id,\n", + " ])\n", + "for line in result.output.split(\"\\n\"):\n", + " print(line)" + ] }, { "cell_type": "code", @@ -230,6 +33562,1057 @@ " print(line)" ] }, + { + "cell_type": "code", + "execution_count": 57, + "id": "3690435c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:27:10 WARN CacheManager: Asked to cache already cached data.\n", + "25/07/30 15:27:10 WARN CacheManager: Asked to cache already cached data.\n" + ] + } + ], + "source": [ + "from click.testing import CliRunner\n", + "from add_a_link import generate_training_data\n", + "wikis = [\"nlwiki\"]\n", + "wikidata_properties = [\"P31\"]\n", + "hdfs_path = \"/tmp/ozge\"\n", + "wikidata_snapshot = \"2025-07-14\"\n", + "model_id = \"shard_nl\"\n", + "snapshot = \"2025-06\"\n", + "files_per_wiki = 5\n", + "runner = CliRunner()\n", + "result = runner.invoke(generate_training_data.main, [\n", + " \"--snapshot\",\n", + " snapshot,\n", + " \"--wiki_dbs\",\n", + " \",\".join(wikis),\n", + " \"--directory\",\n", + " f\"{hdfs_path}/addalink/{model_id}\",\n", + " \"--files_per_wiki\",\n", + " files_per_wiki,\n", + " \"--model_id\",\n", + " model_id\n", + " ])\n", + "for line in result.output.split(\"\\n\"):\n", + " print(line)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "ab872e82", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 14:33:33 WARN SparkContext: The path /srv/home/ozge/anchor_shard_nl.bloom has been added already. Overwriting of added paths is not supported in the current version.\n" + ] + } + ], + "source": [ + "spark.sparkContext.addFile(str(pathlib.Path.cwd() / f\"anchor_{model_id}.bloom\"))\n", + "anchors = rbloom.Bloom.load(\n", + " SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "f4756288", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(\"nlwiki\", \"test\") in anchors" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "f7d82b6e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:34:33 WARN CacheManager: Asked to cache already cached data.\n", + "25/07/30 15:34:33 WARN CacheManager: Asked to cache already cached data.\n", + "25/07/30 15:34:33 WARN SparkContext: The path /srv/home/ozge/anchor_shard_nl.bloom has been added already. Overwriting of added paths is not supported in the current version.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "we're here!!\n", + "we're here2!!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:35:02 WARN TaskSetManager: Lost task 32.0 in stage 808.0 (TID 5778) (an-worker1190.eqiad.wmnet executor 54): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000071/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 22.0 in stage 808.0 (TID 5768) (an-worker1153.eqiad.wmnet executor 57): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 30.0 in stage 808.0 (TID 5776) (an-worker1150.eqiad.wmnet executor 51): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/i/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000064/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 15.0 in stage 808.0 (TID 5761) (an-worker1192.eqiad.wmnet executor 52): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/e/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000065/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 101.0 in stage 808.0 (TID 5847) (an-worker1190.eqiad.wmnet executor 70): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/c/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000087/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 9.0 in stage 808.0 (TID 5755) (an-worker1195.eqiad.wmnet executor 100): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000132/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 46.0 in stage 808.0 (TID 5792) (an-worker1195.eqiad.wmnet executor 67): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/f/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000085/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 89.0 in stage 808.0 (TID 5835) (an-worker1195.eqiad.wmnet executor 76): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000097/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 34.0 in stage 808.0 (TID 5780) (an-worker1168.eqiad.wmnet executor 85): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000118/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 18.0 in stage 808.0 (TID 5764) (an-worker1182.eqiad.wmnet executor 50): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000062/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:03 WARN TaskSetManager: Lost task 25.0 in stage 808.0 (TID 5771) (an-worker1155.eqiad.wmnet executor 69): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000086/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 85.0 in stage 808.0 (TID 5831) (an-worker1155.eqiad.wmnet executor 89): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/a/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000114/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 88.0 in stage 808.0 (TID 5834) (an-worker1192.eqiad.wmnet executor 53): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/b/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000066/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 92.0 in stage 808.0 (TID 5838) (an-worker1120.eqiad.wmnet executor 66): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000083/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 43.0 in stage 808.0 (TID 5789) (an-worker1120.eqiad.wmnet executor 98): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/j/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000129/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 97.0 in stage 808.0 (TID 5843) (an-worker1120.eqiad.wmnet executor 74): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/g/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000094/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 5.0 in stage 808.0 (TID 5751) (an-worker1190.eqiad.wmnet executor 90): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/k/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000115/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 16.0 in stage 808.0 (TID 5762) (an-worker1149.eqiad.wmnet executor 93): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000120/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "25/07/30 15:35:04 ERROR TaskSetManager: Task 32 in stage 808.0 failed 4 times; aborting job\n", + "25/07/30 15:35:04 ERROR FileFormatWriter: Aborting job 727817a6-4cbc-48e3-8d46-81c76a2d6f81.\n", + "org.apache.spark.SparkException: Job aborted due to stage failure: Task 32 in stage 808.0 failed 4 times, most recent failure: Lost task 32.3 in stage 808.0 (TID 5936) (an-worker1153.eqiad.wmnet executor 57): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "\n", + "Driver stacktrace:\n", + "\tat org.apache.spark.scheduler.DAGScheduler.failJobAndIndependentStages(DAGScheduler.scala:2258)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2(DAGScheduler.scala:2207)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2$adapted(DAGScheduler.scala:2206)\n", + "\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n", + "\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n", + "\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:2206)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1(DAGScheduler.scala:1079)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1$adapted(DAGScheduler.scala:1079)\n", + "\tat scala.Option.foreach(Option.scala:407)\n", + "\tat org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:1079)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2445)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n", + "\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n", + "\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n", + "Caused by: org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n", + " func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n", + " arg_offsets, udf = read_single_udf(\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n", + " f, return_type = read_command(pickleSer, infile)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n", + " command = serializer._read_with_length(file)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n", + " return self.loads(obj)\n", + " File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n", + " return pickle.loads(obj, encoding=encoding)\n", + "ModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n", + "\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n", + "\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n", + "\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n", + "\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n", + "\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n", + "\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n", + "\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n", + "\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n", + "\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n", + "\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n", + "\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n", + "\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n", + "\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n", + "\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n", + "\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n", + "\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n", + "\tat java.lang.Thread.run(Thread.java:750)\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 22.2 in stage 808.0 (TID 5937) (an-worker1153.eqiad.wmnet executor 57): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 66.2 in stage 808.0 (TID 5996) (an-worker1153.eqiad.wmnet executor 57): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:04 WARN TaskSetManager: Lost task 31.2 in stage 808.0 (TID 5997) (an-worker1153.eqiad.wmnet executor 57): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 42.1 in stage 808.0 (TID 5943) (an-worker1192.eqiad.wmnet executor 52): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 56.2 in stage 808.0 (TID 5950) (an-worker1192.eqiad.wmnet executor 52): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 30.2 in stage 808.0 (TID 5949) (an-worker1192.eqiad.wmnet executor 52): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 4.2 in stage 808.0 (TID 5952) (an-worker1190.eqiad.wmnet executor 70): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 75.2 in stage 808.0 (TID 5953) (an-worker1190.eqiad.wmnet executor 70): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 48.2 in stage 808.0 (TID 5946) (an-worker1190.eqiad.wmnet executor 70): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 74.2 in stage 808.0 (TID 5947) (an-worker1190.eqiad.wmnet executor 70): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 15.2 in stage 808.0 (TID 5944) (an-worker1150.eqiad.wmnet executor 51): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 100.2 in stage 808.0 (TID 5951) (an-worker1150.eqiad.wmnet executor 51): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 68.1 in stage 808.0 (TID 5948) (an-worker1150.eqiad.wmnet executor 51): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 10.1 in stage 808.0 (TID 5919) (an-worker1120.eqiad.wmnet executor 66): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 92.1 in stage 808.0 (TID 5921) (an-worker1120.eqiad.wmnet executor 98): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 36.1 in stage 808.0 (TID 5918) (an-worker1120.eqiad.wmnet executor 66): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 16.1 in stage 808.0 (TID 5942) (an-worker1149.eqiad.wmnet executor 93): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 83.1 in stage 808.0 (TID 5941) (an-worker1149.eqiad.wmnet executor 93): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 104.2 in stage 808.0 (TID 5940) (an-worker1149.eqiad.wmnet executor 93): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 82.2 in stage 808.0 (TID 5939) (an-worker1149.eqiad.wmnet executor 93): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 107.0 in stage 808.0 (TID 5857) (an-worker1158.eqiad.wmnet executor 58): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 94.1 in stage 808.0 (TID 5945) (an-worker1150.eqiad.wmnet executor 51): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 97.1 in stage 808.0 (TID 5924) (an-worker1120.eqiad.wmnet executor 74): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 14.1 in stage 808.0 (TID 5930) (an-worker1120.eqiad.wmnet executor 74): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 17.1 in stage 808.0 (TID 5932) (an-worker1120.eqiad.wmnet executor 98): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 57.1 in stage 808.0 (TID 5929) (an-worker1120.eqiad.wmnet executor 66): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 40.1 in stage 808.0 (TID 5920) (an-worker1120.eqiad.wmnet executor 98): TaskKilled (Stage cancelled)\n" + ] + }, + { + "ename": "Py4JJavaError", + "evalue": "An error occurred while calling o14819.parquet.\n: org.apache.spark.SparkException: Job aborted.\n\tat org.apache.spark.sql.execution.datasources.FileFormatWriter$.write(FileFormatWriter.scala:231)\n\tat org.apache.spark.sql.execution.datasources.InsertIntoHadoopFsRelationCommand.run(InsertIntoHadoopFsRelationCommand.scala:188)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.sideEffectResult$lzycompute(commands.scala:108)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.sideEffectResult(commands.scala:106)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.doExecute(commands.scala:131)\n\tat org.apache.spark.sql.execution.SparkPlan.$anonfun$execute$1(SparkPlan.scala:180)\n\tat org.apache.spark.sql.execution.SparkPlan.$anonfun$executeQuery$1(SparkPlan.scala:218)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.sql.execution.SparkPlan.executeQuery(SparkPlan.scala:215)\n\tat org.apache.spark.sql.execution.SparkPlan.execute(SparkPlan.scala:176)\n\tat org.apache.spark.sql.execution.QueryExecution.toRdd$lzycompute(QueryExecution.scala:132)\n\tat org.apache.spark.sql.execution.QueryExecution.toRdd(QueryExecution.scala:131)\n\tat org.apache.spark.sql.DataFrameWriter.$anonfun$runCommand$1(DataFrameWriter.scala:989)\n\tat org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$5(SQLExecution.scala:103)\n\tat org.apache.spark.sql.execution.SQLExecution$.withSQLConfPropagated(SQLExecution.scala:163)\n\tat org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$1(SQLExecution.scala:90)\n\tat org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)\n\tat org.apache.spark.sql.execution.SQLExecution$.withNewExecutionId(SQLExecution.scala:64)\n\tat org.apache.spark.sql.DataFrameWriter.runCommand(DataFrameWriter.scala:989)\n\tat org.apache.spark.sql.DataFrameWriter.saveToV1Source(DataFrameWriter.scala:438)\n\tat org.apache.spark.sql.DataFrameWriter.saveInternal(DataFrameWriter.scala:415)\n\tat org.apache.spark.sql.DataFrameWriter.save(DataFrameWriter.scala:293)\n\tat org.apache.spark.sql.DataFrameWriter.parquet(DataFrameWriter.scala:874)\n\tat sun.reflect.GeneratedMethodAccessor152.invoke(Unknown Source)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:498)\n\tat py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:244)\n\tat py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:357)\n\tat py4j.Gateway.invoke(Gateway.java:282)\n\tat py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)\n\tat py4j.commands.CallCommand.execute(CallCommand.java:79)\n\tat py4j.GatewayConnection.run(GatewayConnection.java:238)\n\tat java.lang.Thread.run(Thread.java:750)\nCaused by: org.apache.spark.SparkException: Job aborted due to stage failure: Task 32 in stage 808.0 failed 4 times, most recent failure: Lost task 32.3 in stage 808.0 (TID 5936) (an-worker1153.eqiad.wmnet executor 57): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n arg_offsets, udf = read_single_udf(\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n f, return_type = read_command(pickleSer, infile)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n command = serializer._read_with_length(file)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n return self.loads(obj)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n return pickle.loads(obj, encoding=encoding)\nModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:750)\n\nDriver stacktrace:\n\tat org.apache.spark.scheduler.DAGScheduler.failJobAndIndependentStages(DAGScheduler.scala:2258)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2(DAGScheduler.scala:2207)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2$adapted(DAGScheduler.scala:2206)\n\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n\tat org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:2206)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1(DAGScheduler.scala:1079)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1$adapted(DAGScheduler.scala:1079)\n\tat scala.Option.foreach(Option.scala:407)\n\tat org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:1079)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2445)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\nCaused by: org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n arg_offsets, udf = read_single_udf(\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n f, return_type = read_command(pickleSer, infile)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n command = serializer._read_with_length(file)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n return self.loads(obj)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n return pickle.loads(obj, encoding=encoding)\nModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:750)\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mPy4JJavaError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[64], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpathlib\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01madd_a_link\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m generate_training_data\n\u001b[0;32m----> 3\u001b[0m \u001b[43mgenerate_training_data\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mspark\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msnapshot\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwiki_dbs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwikis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43mdirectory\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpathlib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mPath\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mhdfs_path\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m/addalink/\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mmodel_id\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43mfiles_per_wiki\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfiles_per_wiki\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 6\u001b[0m \u001b[43mmodel_id\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmodel_id\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/srv/home/ozge/repos/wiki/gitlab/ml-pipelines/training/add_a_link/src/add_a_link/generate_training_data.py:400\u001b[0m, in \u001b[0;36mrun\u001b[0;34m(spark, snapshot, wiki_dbs, directory, files_per_wiki, model_id)\u001b[0m\n\u001b[1;32m 380\u001b[0m anchor_links_df \u001b[38;5;241m=\u001b[39m sentences_df\u001b[38;5;241m.\u001b[39mtransform(\n\u001b[1;32m 381\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m df: enrich_with_links(df, pageids_df, redirects_df)\n\u001b[1;32m 382\u001b[0m )\u001b[38;5;241m.\u001b[39mcache()\n\u001b[1;32m 383\u001b[0m features_df \u001b[38;5;241m=\u001b[39m anchor_links_df\u001b[38;5;241m.\u001b[39mtransform(\n\u001b[1;32m 384\u001b[0m \u001b[38;5;28;01mlambda\u001b[39;00m df: enrich_with_candidate_anchors(\n\u001b[1;32m 385\u001b[0m df, spark, canonical_wikis_df, anchors_file, model_id\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 395\u001b[0m )\n\u001b[1;32m 396\u001b[0m )\n\u001b[1;32m 398\u001b[0m \u001b[43mfeatures_df\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrepartition\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfiles_per_wiki\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpartitionBy\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mwiki_db\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 399\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moverwrite\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[0;32m--> 400\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparquet\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdirectory\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtraining/link_train.parquet\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 402\u001b[0m \u001b[38;5;66;03m# save embeddings for inference\u001b[39;00m\n\u001b[1;32m 403\u001b[0m embeddings_df\u001b[38;5;241m.\u001b[39mrepartition(files_per_wiki)\u001b[38;5;241m.\u001b[39mwrite\u001b[38;5;241m.\u001b[39mpartitionBy(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwiki_db\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mmode(\n\u001b[1;32m 404\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moverwrite\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 405\u001b[0m )\u001b[38;5;241m.\u001b[39mparquet(\u001b[38;5;28mstr\u001b[39m(directory \u001b[38;5;241m/\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124membeddings\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyspark/sql/readwriter.py:1250\u001b[0m, in \u001b[0;36mDataFrameWriter.parquet\u001b[0;34m(self, path, mode, partitionBy, compression)\u001b[0m\n\u001b[1;32m 1248\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpartitionBy(partitionBy)\n\u001b[1;32m 1249\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_set_opts(compression\u001b[38;5;241m=\u001b[39mcompression)\n\u001b[0;32m-> 1250\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_jwrite\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparquet\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpath\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/py4j/java_gateway.py:1304\u001b[0m, in \u001b[0;36mJavaMember.__call__\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m 1298\u001b[0m command \u001b[38;5;241m=\u001b[39m proto\u001b[38;5;241m.\u001b[39mCALL_COMMAND_NAME \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1299\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcommand_header \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1300\u001b[0m args_command \u001b[38;5;241m+\u001b[39m\\\n\u001b[1;32m 1301\u001b[0m proto\u001b[38;5;241m.\u001b[39mEND_COMMAND_PART\n\u001b[1;32m 1303\u001b[0m answer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgateway_client\u001b[38;5;241m.\u001b[39msend_command(command)\n\u001b[0;32m-> 1304\u001b[0m return_value \u001b[38;5;241m=\u001b[39m \u001b[43mget_return_value\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1305\u001b[0m \u001b[43m \u001b[49m\u001b[43manswer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgateway_client\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtarget_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1307\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m temp_arg \u001b[38;5;129;01min\u001b[39;00m temp_args:\n\u001b[1;32m 1308\u001b[0m temp_arg\u001b[38;5;241m.\u001b[39m_detach()\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyspark/sql/utils.py:111\u001b[0m, in \u001b[0;36mcapture_sql_exception..deco\u001b[0;34m(*a, **kw)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdeco\u001b[39m(\u001b[38;5;241m*\u001b[39ma, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw):\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 111\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mf\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m py4j\u001b[38;5;241m.\u001b[39mprotocol\u001b[38;5;241m.\u001b[39mPy4JJavaError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 113\u001b[0m converted \u001b[38;5;241m=\u001b[39m convert_exception(e\u001b[38;5;241m.\u001b[39mjava_exception)\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/py4j/protocol.py:326\u001b[0m, in \u001b[0;36mget_return_value\u001b[0;34m(answer, gateway_client, target_id, name)\u001b[0m\n\u001b[1;32m 324\u001b[0m value \u001b[38;5;241m=\u001b[39m OUTPUT_CONVERTER[\u001b[38;5;28mtype\u001b[39m](answer[\u001b[38;5;241m2\u001b[39m:], gateway_client)\n\u001b[1;32m 325\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m answer[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m==\u001b[39m REFERENCE_TYPE:\n\u001b[0;32m--> 326\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m Py4JJavaError(\n\u001b[1;32m 327\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAn error occurred while calling \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[38;5;132;01m{1}\u001b[39;00m\u001b[38;5;132;01m{2}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39m\n\u001b[1;32m 328\u001b[0m \u001b[38;5;28mformat\u001b[39m(target_id, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m, name), value)\n\u001b[1;32m 329\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 330\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m Py4JError(\n\u001b[1;32m 331\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAn error occurred while calling \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[38;5;132;01m{1}\u001b[39;00m\u001b[38;5;132;01m{2}\u001b[39;00m\u001b[38;5;124m. Trace:\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;132;01m{3}\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39m\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28mformat\u001b[39m(target_id, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m, name, value))\n", + "\u001b[0;31mPy4JJavaError\u001b[0m: An error occurred while calling o14819.parquet.\n: org.apache.spark.SparkException: Job aborted.\n\tat org.apache.spark.sql.execution.datasources.FileFormatWriter$.write(FileFormatWriter.scala:231)\n\tat org.apache.spark.sql.execution.datasources.InsertIntoHadoopFsRelationCommand.run(InsertIntoHadoopFsRelationCommand.scala:188)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.sideEffectResult$lzycompute(commands.scala:108)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.sideEffectResult(commands.scala:106)\n\tat org.apache.spark.sql.execution.command.DataWritingCommandExec.doExecute(commands.scala:131)\n\tat org.apache.spark.sql.execution.SparkPlan.$anonfun$execute$1(SparkPlan.scala:180)\n\tat org.apache.spark.sql.execution.SparkPlan.$anonfun$executeQuery$1(SparkPlan.scala:218)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.sql.execution.SparkPlan.executeQuery(SparkPlan.scala:215)\n\tat org.apache.spark.sql.execution.SparkPlan.execute(SparkPlan.scala:176)\n\tat org.apache.spark.sql.execution.QueryExecution.toRdd$lzycompute(QueryExecution.scala:132)\n\tat org.apache.spark.sql.execution.QueryExecution.toRdd(QueryExecution.scala:131)\n\tat org.apache.spark.sql.DataFrameWriter.$anonfun$runCommand$1(DataFrameWriter.scala:989)\n\tat org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$5(SQLExecution.scala:103)\n\tat org.apache.spark.sql.execution.SQLExecution$.withSQLConfPropagated(SQLExecution.scala:163)\n\tat org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$1(SQLExecution.scala:90)\n\tat org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)\n\tat org.apache.spark.sql.execution.SQLExecution$.withNewExecutionId(SQLExecution.scala:64)\n\tat org.apache.spark.sql.DataFrameWriter.runCommand(DataFrameWriter.scala:989)\n\tat org.apache.spark.sql.DataFrameWriter.saveToV1Source(DataFrameWriter.scala:438)\n\tat org.apache.spark.sql.DataFrameWriter.saveInternal(DataFrameWriter.scala:415)\n\tat org.apache.spark.sql.DataFrameWriter.save(DataFrameWriter.scala:293)\n\tat org.apache.spark.sql.DataFrameWriter.parquet(DataFrameWriter.scala:874)\n\tat sun.reflect.GeneratedMethodAccessor152.invoke(Unknown Source)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:498)\n\tat py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:244)\n\tat py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:357)\n\tat py4j.Gateway.invoke(Gateway.java:282)\n\tat py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)\n\tat py4j.commands.CallCommand.execute(CallCommand.java:79)\n\tat py4j.GatewayConnection.run(GatewayConnection.java:238)\n\tat java.lang.Thread.run(Thread.java:750)\nCaused by: org.apache.spark.SparkException: Job aborted due to stage failure: Task 32 in stage 808.0 failed 4 times, most recent failure: Lost task 32.3 in stage 808.0 (TID 5936) (an-worker1153.eqiad.wmnet executor 57): org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n arg_offsets, udf = read_single_udf(\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n f, return_type = read_command(pickleSer, infile)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n command = serializer._read_with_length(file)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n return self.loads(obj)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n return pickle.loads(obj, encoding=encoding)\nModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:750)\n\nDriver stacktrace:\n\tat org.apache.spark.scheduler.DAGScheduler.failJobAndIndependentStages(DAGScheduler.scala:2258)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2(DAGScheduler.scala:2207)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$abortStage$2$adapted(DAGScheduler.scala:2206)\n\tat scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n\tat scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n\tat org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:2206)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1(DAGScheduler.scala:1079)\n\tat org.apache.spark.scheduler.DAGScheduler.$anonfun$handleTaskSetFailed$1$adapted(DAGScheduler.scala:1079)\n\tat scala.Option.foreach(Option.scala:407)\n\tat org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:1079)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2445)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2387)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2376)\n\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\nCaused by: org.apache.spark.api.python.PythonException: Traceback (most recent call last):\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 588, in main\n func, profiler, deserializer, serializer = read_udfs(pickleSer, infile, eval_type)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 336, in read_udfs\n arg_offsets, udf = read_single_udf(\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 249, in read_single_udf\n f, return_type = read_command(pickleSer, infile)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/worker.py\", line 69, in read_command\n command = serializer._read_with_length(file)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 160, in _read_with_length\n return self.loads(obj)\n File \"/var/lib/hadoop/data/l/yarn/local/usercache/ozge/appcache/application_1750705250302_1129604/container_e137_1750705250302_1129604_01_000070/pyspark.zip/pyspark/serializers.py\", line 430, in loads\n return pickle.loads(obj, encoding=encoding)\nModuleNotFoundError: No module named 'add_a_link.generate_training_data'\n\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.handlePythonException(PythonRunner.scala:517)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:99)\n\tat org.apache.spark.sql.execution.python.PythonArrowOutput$$anon$1.read(PythonArrowOutput.scala:49)\n\tat org.apache.spark.api.python.BasePythonRunner$ReaderIterator.hasNext(PythonRunner.scala:470)\n\tat org.apache.spark.InterruptibleIterator.hasNext(InterruptibleIterator.scala:37)\n\tat scala.collection.Iterator$$anon$11.hasNext(Iterator.scala:489)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.sql.catalyst.expressions.GeneratedClass$GeneratedIteratorForCodegenStage8.processNext(Unknown Source)\n\tat org.apache.spark.sql.execution.BufferedRowIterator.hasNext(BufferedRowIterator.java:43)\n\tat org.apache.spark.sql.execution.WholeStageCodegenExec$$anon$1.hasNext(WholeStageCodegenExec.scala:755)\n\tat scala.collection.Iterator$$anon$10.hasNext(Iterator.scala:458)\n\tat org.apache.spark.shuffle.sort.UnsafeShuffleWriter.write(UnsafeShuffleWriter.java:177)\n\tat org.apache.spark.shuffle.ShuffleWriteProcessor.write(ShuffleWriteProcessor.scala:59)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:52)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:131)\n\tat org.apache.spark.executor.Executor$TaskRunner.$anonfun$run$3(Executor.scala:497)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1439)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:500)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:750)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 45.1 in stage 808.0 (TID 5931) (an-worker1120.eqiad.wmnet executor 98): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 69.1 in stage 808.0 (TID 5922) (an-worker1120.eqiad.wmnet executor 74): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 43.1 in stage 808.0 (TID 5923) (an-worker1120.eqiad.wmnet executor 74): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 95.1 in stage 808.0 (TID 5933) (an-worker1120.eqiad.wmnet executor 66): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 63.2 in stage 808.0 (TID 5956) (an-worker1195.eqiad.wmnet executor 76): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 0.0 in stage 798.0 (TID 1703) (an-worker1155.eqiad.wmnet executor 49): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 61.2 in stage 808.0 (TID 5959) (an-worker1195.eqiad.wmnet executor 67): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 49.2 in stage 808.0 (TID 5955) (an-worker1195.eqiad.wmnet executor 76): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 101.2 in stage 808.0 (TID 5954) (an-worker1195.eqiad.wmnet executor 76): TaskKilled (Stage cancelled)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 9.2 in stage 808.0 (TID 5958) (an-worker1195.eqiad.wmnet executor 67): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 41.2 in stage 808.0 (TID 5960) (an-worker1195.eqiad.wmnet executor 100): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 98.2 in stage 808.0 (TID 5957) (an-worker1195.eqiad.wmnet executor 100): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 109.0 in stage 808.0 (TID 5859) (an-worker1158.eqiad.wmnet executor 55): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 108.0 in stage 808.0 (TID 5858) (an-worker1158.eqiad.wmnet executor 55): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 110.0 in stage 808.0 (TID 5860) (an-worker1158.eqiad.wmnet executor 55): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 111.0 in stage 808.0 (TID 5861) (an-worker1158.eqiad.wmnet executor 55): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 93.2 in stage 808.0 (TID 5961) (an-worker1195.eqiad.wmnet executor 100): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 87.2 in stage 808.0 (TID 5969) (an-worker1195.eqiad.wmnet executor 67): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 70.2 in stage 808.0 (TID 5973) (an-worker1190.eqiad.wmnet executor 54): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 67.2 in stage 808.0 (TID 5974) (an-worker1190.eqiad.wmnet executor 54): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 96.2 in stage 808.0 (TID 5972) (an-worker1190.eqiad.wmnet executor 54): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 34.2 in stage 808.0 (TID 5964) (an-worker1195.eqiad.wmnet executor 76): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 20.2 in stage 808.0 (TID 5967) (an-worker1168.eqiad.wmnet executor 85): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 72.2 in stage 808.0 (TID 5963) (an-worker1168.eqiad.wmnet executor 85): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 23.2 in stage 808.0 (TID 5962) (an-worker1168.eqiad.wmnet executor 85): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 60.2 in stage 808.0 (TID 5966) (an-worker1168.eqiad.wmnet executor 85): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 88.2 in stage 808.0 (TID 5977) (an-worker1192.eqiad.wmnet executor 53): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 51.2 in stage 808.0 (TID 5979) (an-worker1192.eqiad.wmnet executor 53): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 113.2 in stage 808.0 (TID 5978) (an-worker1192.eqiad.wmnet executor 53): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 25.2 in stage 808.0 (TID 5976) (an-worker1192.eqiad.wmnet executor 53): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 89.2 in stage 808.0 (TID 5965) (an-worker1195.eqiad.wmnet executor 100): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 8.2 in stage 808.0 (TID 5981) (an-worker1190.eqiad.wmnet executor 54): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 37.2 in stage 808.0 (TID 5968) (an-worker1195.eqiad.wmnet executor 67): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 11.2 in stage 808.0 (TID 5970) (an-worker1155.eqiad.wmnet executor 69): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 46.2 in stage 808.0 (TID 5971) (an-worker1155.eqiad.wmnet executor 69): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 77.2 in stage 808.0 (TID 5975) (an-worker1155.eqiad.wmnet executor 69): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 59.2 in stage 808.0 (TID 5990) (an-worker1190.eqiad.wmnet executor 90): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 71.2 in stage 808.0 (TID 5992) (an-worker1190.eqiad.wmnet executor 90): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 62.2 in stage 808.0 (TID 5993) (an-worker1190.eqiad.wmnet executor 90): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 5.2 in stage 808.0 (TID 5991) (an-worker1190.eqiad.wmnet executor 90): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 19.2 in stage 808.0 (TID 5994) (an-worker1192.eqiad.wmnet executor 52): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 7.2 in stage 808.0 (TID 5980) (an-worker1155.eqiad.wmnet executor 69): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 58.1 in stage 808.0 (TID 5855) (an-worker1158.eqiad.wmnet executor 58): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 6.1 in stage 808.0 (TID 5856) (an-worker1158.eqiad.wmnet executor 58): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 84.1 in stage 808.0 (TID 5854) (an-worker1158.eqiad.wmnet executor 58): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 44.2 in stage 808.0 (TID 5984) (an-worker1155.eqiad.wmnet executor 89): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 3.0 in stage 798.0 (TID 1706) (an-worker1155.eqiad.wmnet executor 49): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 85.2 in stage 808.0 (TID 5985) (an-worker1155.eqiad.wmnet executor 89): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 35.2 in stage 808.0 (TID 5988) (an-worker1155.eqiad.wmnet executor 89): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 33.2 in stage 808.0 (TID 5989) (an-worker1155.eqiad.wmnet executor 89): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 73.0 in stage 808.0 (TID 5819) (an-worker1175.eqiad.wmnet executor 56): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 47.0 in stage 808.0 (TID 5793) (an-worker1175.eqiad.wmnet executor 56): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 99.0 in stage 808.0 (TID 5845) (an-worker1175.eqiad.wmnet executor 56): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 114.2 in stage 808.0 (TID 5995) (an-worker1153.eqiad.wmnet executor 57): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 112.2 in stage 808.0 (TID 5982) (an-worker1182.eqiad.wmnet executor 50): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 21.0 in stage 808.0 (TID 5767) (an-worker1175.eqiad.wmnet executor 56): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 106.3 in stage 808.0 (TID 5986) (an-worker1182.eqiad.wmnet executor 50): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 18.2 in stage 808.0 (TID 5983) (an-worker1182.eqiad.wmnet executor 50): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 86.2 in stage 808.0 (TID 5987) (an-worker1182.eqiad.wmnet executor 50): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 52.0 in stage 808.0 (TID 5798) (an-worker1175.eqiad.wmnet executor 88): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 78.0 in stage 808.0 (TID 5824) (an-worker1175.eqiad.wmnet executor 88): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 26.0 in stage 808.0 (TID 5772) (an-worker1175.eqiad.wmnet executor 88): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 0.0 in stage 808.0 (TID 5746) (an-worker1175.eqiad.wmnet executor 88): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 3.0 in stage 808.0 (TID 5749) (an-worker1175.eqiad.wmnet executor 59): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 29.0 in stage 808.0 (TID 5775) (an-worker1175.eqiad.wmnet executor 59): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 55.0 in stage 808.0 (TID 5801) (an-worker1175.eqiad.wmnet executor 59): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:05 WARN TaskSetManager: Lost task 81.0 in stage 808.0 (TID 5827) (an-worker1175.eqiad.wmnet executor 59): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 76.0 in stage 808.0 (TID 5822) (an-worker1167.eqiad.wmnet executor 81): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 50.0 in stage 808.0 (TID 5796) (an-worker1167.eqiad.wmnet executor 81): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 102.0 in stage 808.0 (TID 5848) (an-worker1167.eqiad.wmnet executor 81): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 24.0 in stage 808.0 (TID 5770) (an-worker1167.eqiad.wmnet executor 81): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 65.0 in stage 808.0 (TID 5811) (an-worker1127.eqiad.wmnet executor 102): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 91.0 in stage 808.0 (TID 5837) (an-worker1127.eqiad.wmnet executor 102): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 13.0 in stage 808.0 (TID 5759) (an-worker1127.eqiad.wmnet executor 102): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 39.0 in stage 808.0 (TID 5785) (an-worker1127.eqiad.wmnet executor 102): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 1.0 in stage 808.0 (TID 5747) (an-worker1127.eqiad.wmnet executor 78): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 53.0 in stage 808.0 (TID 5799) (an-worker1127.eqiad.wmnet executor 78): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 27.0 in stage 808.0 (TID 5773) (an-worker1127.eqiad.wmnet executor 78): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 79.0 in stage 808.0 (TID 5825) (an-worker1127.eqiad.wmnet executor 78): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 2.0 in stage 798.0 (TID 1705) (an-worker1155.eqiad.wmnet executor 49): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 1.0 in stage 798.0 (TID 1704) (an-worker1155.eqiad.wmnet executor 49): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 12.0 in stage 808.0 (TID 5758) (an-worker1197.eqiad.wmnet executor 65): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 64.0 in stage 808.0 (TID 5810) (an-worker1197.eqiad.wmnet executor 65): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 38.0 in stage 808.0 (TID 5784) (an-worker1197.eqiad.wmnet executor 65): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:06 WARN TaskSetManager: Lost task 90.0 in stage 808.0 (TID 5836) (an-worker1197.eqiad.wmnet executor 65): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:08 WARN TaskSetManager: Lost task 28.0 in stage 808.0 (TID 5774) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:08 WARN TaskSetManager: Lost task 2.0 in stage 808.0 (TID 5748) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:08 WARN TaskSetManager: Lost task 80.0 in stage 808.0 (TID 5826) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", + "25/07/30 15:35:08 WARN TaskSetManager: Lost task 54.0 in stage 808.0 (TID 5800) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n" + ] + } + ], + "source": [ + "import pathlib\n", + "from add_a_link import generate_training_data\n", + "generate_training_data.run(spark, snapshot, wiki_dbs=wikis, \n", + "directory =pathlib.Path(f\"{hdfs_path}/addalink/{model_id}\"), \n", + "files_per_wiki=files_per_wiki,\n", + "model_id=model_id)" + ] + }, { "cell_type": "code", "execution_count": 43, @@ -261,7 +34644,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "id": "5821e769", "metadata": {}, "outputs": [ @@ -269,13 +34652,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 1 items\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 10:20 /tmp/ozge2/addalink/shard_nl/wdproperties\n" + "Found 8 items\n", + "-rw-r----- 3 ozge hdfs 59906623 2025-07-30 12:39 /tmp/ozge/addalink/shard_nl/anchor_shard_nl.bloom\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 12:35 /tmp/ozge/addalink/shard_nl/anchors\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 10:56 /tmp/ozge/addalink/shard_nl/anchors_filtered\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 12:17 /tmp/ozge/addalink/shard_nl/pageids\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 12:17 /tmp/ozge/addalink/shard_nl/redirects\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 11:03 /tmp/ozge/addalink/shard_nl/testing\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 10:57 /tmp/ozge/addalink/shard_nl/training\n", + "drwxr-x--- - ozge hdfs 0 2025-07-30 10:54 /tmp/ozge/addalink/shard_nl/wdproperties\n" ] } ], "source": [ - "!hdfs dfs -ls /tmp/ozge2/addalink/shard_nl" + "!hdfs dfs -ls /tmp/ozge/addalink/shard_nl/" ] }, { @@ -288,7 +34678,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "id": "99e21fd9", "metadata": {}, "outputs": [ @@ -296,6 +34686,7 @@ "name": "stderr", "output_type": "stream", "text": [ + "25/07/30 12:13:42 WARN YarnScheduler: Initial job has not accepted any resources; check your cluster UI to ensure that workers are registered and have sufficient resources\n", " \r" ] }, @@ -303,14 +34694,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " \r" + "1429935\n" ] }, { @@ -335,28 +34719,69 @@ " \n", " \n", " wiki_db\n", - " page_id\n", - " statement_value_qid\n", + " anchor\n", + " link_occurrence\n", " \n", " \n", " \n", + " \n", + " 0\n", + " nlwiki\n", + " \"scuderia duke\"\n", + " {'Gilera 500 4C': 3}\n", + " \n", + " \n", + " 1\n", + " nlwiki\n", + " '''2000'''\n", + " {'Europees kampioenschap handbal mannen 2000':...\n", + " \n", + " \n", + " 2\n", + " nlwiki\n", + " '''tinglev-sønderborg'''\n", + " {'Spoorlijn Sønderborg - Tinglev': 1}\n", + " \n", + " \n", + " 3\n", + " nlwiki\n", + " '''westfriesland/sew 2'''\n", + " {'HV SEW': 1}\n", + " \n", + " \n", + " 4\n", + " nlwiki\n", + " ''admiraal gorshkov''\n", + " {'Admiraal Gorsjkov (schip)': 1}\n", + " \n", " \n", "\n", "" ], "text/plain": [ - "Empty DataFrame\n", - "Columns: [wiki_db, page_id, statement_value_qid]\n", - "Index: []" + " wiki_db anchor \\\n", + "0 nlwiki \"scuderia duke\" \n", + "1 nlwiki '''2000''' \n", + "2 nlwiki '''tinglev-sønderborg''' \n", + "3 nlwiki '''westfriesland/sew 2''' \n", + "4 nlwiki ''admiraal gorshkov'' \n", + "\n", + " link_occurrence \n", + "0 {'Gilera 500 4C': 3} \n", + "1 {'Europees kampioenschap handbal mannen 2000':... \n", + "2 {'Spoorlijn Sønderborg - Tinglev': 1} \n", + "3 {'HV SEW': 1} \n", + "4 {'Admiraal Gorsjkov (schip)': 1} " ] }, - "execution_count": 16, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df_anchors = spark.read.parquet(\"/tmp/ozge2/addalink/shard_nl/wdproperties\")\n", + "df_anchors = spark.read.parquet(\"/tmp/ozge/addalink/shard_nl/anchors_filtered\")\n", + "# df_anchors = spark.read.parquet(\"/tmp/ozge/addalink/shard_nl/anchors\")\n", "print(df_anchors.count())\n", "df_anchors.limit(5).toPandas()" ] @@ -1649,11 +36074,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "6cf47121", "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/07/30 12:57:46 WARN SparkContext: The path hdfs:///tmp/ozge/addalink/shard_nl/anchor_shard_nl.bloom has been added already. Overwriting of added paths is not supported in the current version.\n" + ] + } + ], + "source": [ + "directory = pathlib.Path(f\"{hdfs_path}/addalink/{model_id}\")\n", + "anchors_file = \"hdfs://\" + str(directory / f\"anchor_{model_id}.bloom\")\n", + "spark.sparkContext.addFile(path=anchors_file)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2b282bc", + "metadata": {}, "outputs": [], - "source": [] + "source": [ + "anchors = rbloom.Bloom.load(\n", + " SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash\n", + " )" + ] } ], "metadata": { @@ -1661,6 +36110,18 @@ "display_name": "add_a_link_remote", "language": "python", "name": "add_a_link_remote" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" } }, "nbformat": 4, diff --git a/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb b/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb index 7f78ea8..274030e 100644 --- a/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/rbloom_example.ipynb @@ -287,19 +287,20 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 1, "id": "9ed66b98", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" + "ename": "NameError", + "evalue": "name 'bloom_file' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124maa\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01min\u001b[39;00m \u001b[43mbloom_file\u001b[49m\n", + "\u001b[0;31mNameError\u001b[0m: name 'bloom_file' is not defined" + ] } ], "source": [ @@ -353,9 +354,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "3b70b642", "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'rbloom' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m anchors \u001b[38;5;241m=\u001b[39m \u001b[43mrbloom\u001b[49m\u001b[38;5;241m.\u001b[39mBloom\u001b[38;5;241m.\u001b[39mload(\n\u001b[1;32m 2\u001b[0m SparkFiles\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124manchor_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.bloom\u001b[39m\u001b[38;5;124m\"\u001b[39m), compute_hash\n\u001b[1;32m 3\u001b[0m )\n", + "\u001b[0;31mNameError\u001b[0m: name 'rbloom' is not defined" + ] + } + ], + "source": [ + "anchors = rbloom.Bloom.load(\n", + " SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abe83a72", + "metadata": {}, "outputs": [], "source": [] } -- GitLab From 95f0a4d7354819737a288c23bddcbc96df2f9f3d Mon Sep 17 00:00:00 2001 From: ozge Date: Wed, 30 Jul 2025 18:30:20 +0200 Subject: [PATCH 07/13] feat: adds addalink steps --- .../src/add_a_link/generate_training_data.py | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/training/add_a_link/src/add_a_link/generate_training_data.py b/training/add_a_link/src/add_a_link/generate_training_data.py index 4f1c0b2..d260cc0 100644 --- a/training/add_a_link/src/add_a_link/generate_training_data.py +++ b/training/add_a_link/src/add_a_link/generate_training_data.py @@ -1,5 +1,6 @@ import pathlib from collections.abc import Iterable, Iterator, Sequence +import subprocess import click import mwparserfromhell as mwph # type: ignore[import-untyped] @@ -105,10 +106,10 @@ def enrich_with_candidate_anchors( df: DataFrame, spark: SparkSession, canonical_wikis: DataFrame, - anchors_file: str, + anchors_file: pathlib.Path, model_id: str, ) -> Transformation: - spark.sparkContext.addFile(str(pathlib.Path.cwd() / f"anchor_{model_id}.bloom")) + spark.sparkContext.addFile(str(anchors_file)) candidate_anchors_schema = T.StructType( [ @@ -124,7 +125,7 @@ def enrich_with_candidate_anchors( # Load the bloom filter containing all known anchors ahead of # processing any batches so we only load it once. anchors = rbloom.Bloom.load( - SparkFiles.get(f"anchor_{model_id}.bloom"), compute_hash + SparkFiles.get(anchors_file.name), compute_hash ) for batch in sentence_batches: @@ -351,7 +352,14 @@ def run( Positive example: The correct link Negative example: identified mentions and all candidate links """ - anchors_file = "hdfs://" + str(directory / f"anchor_{model_id}.bloom") + anchors_file = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" + subprocess.run( + ["hdfs", "dfs", "-get", str(directory / f"anchor_{model_id}.bloom"), str(anchors_file)], + check=True, + capture_output=True, + text=True, + ) + anchors_df = spark.read.parquet(str(directory / "anchors_filtered")) pageids_df = ( spark.read.parquet(str(directory / "pageids")) -- GitLab From 50a5f23a44bf16775e97de5b654a1a9cba6dcc94 Mon Sep 17 00:00:00 2001 From: ozge Date: Wed, 30 Jul 2025 19:23:42 +0200 Subject: [PATCH 08/13] feat: adds addalink steps --- .../src/add_a_link/generate_addlink_model.py | 8 +- .../add_a_link/notebooks/pipeline_run.ipynb | 1125 ++++++++++++++++- 2 files changed, 1128 insertions(+), 5 deletions(-) diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py index 71432d6..ed78949 100644 --- a/training/add_a_link/src/add_a_link/generate_addlink_model.py +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -1,7 +1,7 @@ import multiprocessing import pathlib from collections.abc import Sequence - +from pyspark.sql import SparkSession import click import fsspec # type: ignore[import-untyped] import joblib # type: ignore[import-untyped] @@ -98,6 +98,7 @@ def perform_grid_search(df_small: pd.DataFrame, n_cpus_max: int) -> GridSearchCV def run( # noqa: PLR0915 + spark: SparkSession, wiki_dbs: Sequence[str], model_id: str, directory: pathlib.Path, @@ -121,7 +122,7 @@ def run( # noqa: PLR0915 for wiki in wiki_dbs: try: path = directory / "training" / "link_train.parquet" / f"wiki_db={wiki}" - wiki_df = pd.read_parquet(hdfs_path(path)) + wiki_df = spark.read.parquet(str(path)).toPandas() wiki_df["wiki_db"] = wiki except Exception as e: print("ERROR: ", type(e).__name__, e) # if file not found, skip wiki @@ -211,9 +212,10 @@ def run( # noqa: PLR0915 @click.option("--directory", required=True) @click.option("--grid_search", type=bool, default=False, help="A boolean flag") def main(wiki_dbs: str, model_id: str, directory: str, grid_search: bool): + spark = SparkSession.builder.getOrCreate() directory_input = pathlib.Path(directory) wiki_dbs_input = wiki_dbs.split(",") - run(wiki_dbs_input, model_id, directory_input, grid_search) + run(spark, wiki_dbs_input, model_id, directory_input, grid_search) if __name__ == "__main__": diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index fa89c3e..f8bcc43 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -33655,7 +33655,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "id": "f7d82b6e", "metadata": {}, "outputs": [ @@ -34600,7 +34600,1117 @@ "25/07/30 15:35:08 WARN TaskSetManager: Lost task 28.0 in stage 808.0 (TID 5774) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", "25/07/30 15:35:08 WARN TaskSetManager: Lost task 2.0 in stage 808.0 (TID 5748) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", "25/07/30 15:35:08 WARN TaskSetManager: Lost task 80.0 in stage 808.0 (TID 5826) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", - "25/07/30 15:35:08 WARN TaskSetManager: Lost task 54.0 in stage 808.0 (TID 5800) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n" + "25/07/30 15:35:08 WARN TaskSetManager: Lost task 54.0 in stage 808.0 (TID 5800) (an-worker1166.eqiad.wmnet executor 87): TaskKilled (Stage cancelled)\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_42 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_16 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_94 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_68 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_60 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_34 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_8 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_86 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_102 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_76 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_50 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_24 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_25 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_51 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_77 !\n", + "25/07/30 16:35:06 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_103 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_85 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_7 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_59 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_33 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_383 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_546 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_13 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_623 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_973 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_26 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_753 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_341 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_739 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_298 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_427 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_160 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_284 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_517 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_419 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_11 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_678 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_817 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_897 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_547 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_622 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_887 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_655 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_343 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_499 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_635 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_884 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_252 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_815 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_181 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_928 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_273 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_534 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_484 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_972 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_856 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_567 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_9 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_712 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_18 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_658 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_151 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_998 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_507 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_195 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_10 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_991 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_506 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_196 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_533 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_823 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_927 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_368 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_412 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_677 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_25 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_710 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_686 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_885 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_96 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_27 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_312 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_990 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_128 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_231 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_269 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_561 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_696 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_215 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_866 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_224 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_374 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_711 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_491 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_902 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_262 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_585 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_240 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_166 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_535 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_450 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_667 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_845 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_839 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_824 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_369 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_488 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_261 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_646 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_113 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_634 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_698 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_566 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_932 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_462 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_602 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_644 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_993 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_477 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_323 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_469 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_684 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_777 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_624 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_167 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_297 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_505 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_645 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_129 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_587 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_461 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_857 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_329 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_485 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_643 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_362 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_869 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_44 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_198 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_970 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_435 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_548 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_741 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_170 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_325 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_366 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_70 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_340 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_370 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_420 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_604 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_699 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_656 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_150 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_260 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_345 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_588 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_142 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_670 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_140 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_818 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_754 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_497 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_147 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_948 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_208 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_742 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_776 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_453 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_399 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_296 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_791 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_898 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_149 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_750 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_179 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_848 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_159 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_953 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_788 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_476 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_586 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_855 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_992 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_831 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_436 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_162 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_279 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_324 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_212 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_724 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_603 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_749 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_169 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_766 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_155 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_251 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_14 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_687 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_489 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_12 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_601 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_107 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_270 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_952 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_520 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_518 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_372 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_428 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_685 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_441 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_915 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_847 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_373 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_697 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_490 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_8 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_841 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_896 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_679 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_780 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_301 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_765 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_713 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_182 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_496 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_560 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_762 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_949 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_779 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_310 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_139 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_519 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_180 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_213 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_916 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_764 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_536 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_913 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_384 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_789 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_108 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_406 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_867 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_816 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_109 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_790 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_825 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_545 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_498 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_636 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_508 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_868 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_126 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_926 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_266 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_311 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_314 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_886 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_15 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_668 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_676 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_127 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_287 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_633 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_468 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_248 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_854 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_413 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_669 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_285 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_239 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_197 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_408 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_738 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_625 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_449 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_725 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_728 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_401 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_141 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_840 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_657 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_849 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_971 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_238 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_452 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_914 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_723 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_440 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_24 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_247 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_283 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_46 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_20 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_98 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_72 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_89 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_11 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_63 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_37 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_87 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_61 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_9 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_35 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_945 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_29 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_135 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_580 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_49 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_650 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_783 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_736 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_905 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_186 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_693 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_391 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_37 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_294 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_112 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_821 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_805 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_349 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_632 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_835 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_59 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_653 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_556 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_606 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_111 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_480 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_18 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_999 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_807 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_503 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_576 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_553 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_201 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_812 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_443 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_543 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_995 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_44 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_570 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_830 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_481 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_188 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_68 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_194 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_781 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_568 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_748 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_500 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_229 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_771 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_36 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_513 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_347 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_731 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_322 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_51 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_718 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_35 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_376 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_438 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_706 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_782 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_69 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_442 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_76 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_277 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_115 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_729 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_207 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_966 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_763 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_890 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_735 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_319 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_810 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_220 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_104 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_221 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_377 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_829 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_85 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_472 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_923 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_944 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_793 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_381 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_479 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_522 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_342 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_704 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_511 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_901 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_935 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_84 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_417 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_530 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_911 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_81 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_245 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_592 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_798 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_758 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_838 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_934 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_961 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_230 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_307 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_455 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_747 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_799 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_836 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_761 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_386 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_465 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_694 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_90 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_981 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_579 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_56 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_525 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_757 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_50 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_919 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_922 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_211 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_394 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_99 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_136 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_956 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_106 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_819 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_638 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_555 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_994 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_893 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_30 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_562 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_501 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_590 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_483 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_57 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_281 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_64 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_878 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_959 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_640 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_769 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_45 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_183 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_454 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_280 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_521 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_695 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_532 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_396 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_863 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_986 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_755 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_598 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_184 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_618 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_6 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_942 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_639 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_770 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_28 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_332 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_717 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_591 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_1 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_574 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_357 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_542 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_333 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_880 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_988 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_371 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_112 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_210 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_222 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_891 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_74 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_84 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_124 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_827 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_105 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_464 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_860 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_611 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_619 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_302 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_734 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_977 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_573 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_612 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_330 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_430 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_943 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_946 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_60 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_416 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_872 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_336 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_792 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_346 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_20 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_873 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_904 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_531 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_103 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_38 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_589 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_2 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_46 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_199 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_289 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_703 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_295 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_726 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_134 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_393 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_300 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_445 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_457 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_73 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_250 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_705 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_414 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_47 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_474 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_105 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_40 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_730 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_936 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_348 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_629 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_900 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_171 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_138 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_415 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_94 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_268 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_282 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_722 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_957 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_967 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_820 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_404 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_795 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_929 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_466 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_596 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_463 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_621 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_879 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_123 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_523 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_775 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_785 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_121 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_630 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_334 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_264 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_617 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_241 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_335 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_423 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_249 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_947 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_88 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_308 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_882 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_432 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_540 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_937 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_613 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_909 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_648 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_651 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_187 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_794 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_565 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_320 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_528 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_581 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_960 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_232 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_92 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_122 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_549 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_797 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_355 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_663 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_822 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_403 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_275 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_716 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_278 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_599 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_767 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_862 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_502 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_987 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_715 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_67 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_610 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_514 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_267 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_664 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_828 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_910 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_837 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_456 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_48 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_691 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_804 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_299 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_983 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_202 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_98 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_356 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_233 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_91 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_743 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_185 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_114 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_814 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_17 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_437 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_997 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_515 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_175 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_969 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_58 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_407 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_119 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_577 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_104 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_354 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_471 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_58 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_429 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_746 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_671 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_980 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_875 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_276 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_375 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_806 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_864 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_968 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_784 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_265 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_259 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_255 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_563 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_254 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_172 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_908 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_106 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_219 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_958 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_892 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_87 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_193 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_385 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_3 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_16 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_174 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_395 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_768 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_133 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_600 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_637 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_813 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_918 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_200 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_113 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_475 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_387 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_541 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_321 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_996 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_313 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_424 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_402 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_554 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_425 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_66 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_978 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_253 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_290 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_32 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_286 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_137 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_209 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_756 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_930 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_223 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_874 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_662 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_801 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_309 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_4 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_120 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_444 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_75 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_49 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_23 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_101 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_31 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_83 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_57 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_5 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_82 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_56 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_30 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_4 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_99 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_73 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_47 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_21 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_12 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_38 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_90 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_64 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_15 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_93 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_67 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_41 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_10 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_62 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_36 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_88 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_538 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_681 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_228 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_921 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_236 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_852 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_360 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_418 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_48 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_559 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_846 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_163 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_709 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_865 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_467 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_539 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_125 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_173 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_714 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_258 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_451 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_963 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_359 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_439 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_773 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_673 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_989 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_537 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_304 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_118 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_578 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_54 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_843 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_834 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_861 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_842 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_96 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_31 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_117 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_512 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_100 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_189 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_205 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_665 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_524 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_22 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_353 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_39 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_620 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_674 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_708 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_575 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_422 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_982 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_631 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_478 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_615 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_65 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_907 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_881 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_871 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_43 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_52 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_352 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_225 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_931 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_116 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_720 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_760 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_809 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_950 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_494 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_405 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_78 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_460 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_920 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_293 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_317 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_751 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_595 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_21 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_409 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_426 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_86 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_614 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_772 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_421 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_661 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_190 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_62 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_131 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_305 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_641 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_666 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_361 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_870 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_558 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_851 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_955 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_55 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_274 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_682 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_702 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_344 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_649 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_594 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_217 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_263 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_168 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_495 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_492 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_744 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_326 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_6 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_246 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_707 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_940 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_338 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_895 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_826 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_833 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_19 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_392 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_379 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_410 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_627 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_101 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_146 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_388 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_95 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_680 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_132 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_291 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_925 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_367 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_358 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_877 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_23 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_61 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_75 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_516 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_607 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_721 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_802 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_774 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_130 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_529 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_609 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_550 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_82 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_853 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_148 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_176 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_727 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_144 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_206 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_660 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_227 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_458 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_526 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_161 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_582 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_203 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_583 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_448 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_719 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_740 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_689 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_850 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_608 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_378 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_605 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_551 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_808 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_165 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_226 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_954 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_272 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_889 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_917 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_191 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_41 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_752 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_652 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_447 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_803 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_145 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_257 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_337 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_654 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_178 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_143 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_110 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_63 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_941 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_97 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_701 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_486 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_487 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_80 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_318 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_951 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_400 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_365 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_153 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_975 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_509 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_659 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_83 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_350 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_33 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_177 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_965 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_351 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_390 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_434 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_700 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_675 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_628 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_984 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_79 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_397 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_962 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_71 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_470 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_672 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_778 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_692 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_811 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_939 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_5 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_759 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_899 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_70 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_564 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_616 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_7 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_544 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_552 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_647 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_787 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_77 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_242 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_690 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_237 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_883 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_737 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_786 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_800 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_32 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_876 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_527 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_683 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_102 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_431 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_364 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_114 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_0 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_844 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_593 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_933 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_72 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_363 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_733 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_924 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_446 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_411 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_331 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_89 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_306 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_572 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_292 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_894 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_398 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_243 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_964 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_288 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_216 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_100 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_510 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_315 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_482 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_745 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_234 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_569 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_192 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_42 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_204 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_473 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_571 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_271 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_93 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_327 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_504 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_597 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_339 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_906 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_235 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_979 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_152 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_34 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_832 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_256 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_22 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_493 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_459 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_688 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_156 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_642 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_158 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_557 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_154 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_985 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_389 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_218 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_382 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_974 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_976 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_796 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_859 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_858 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_244 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_214 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_74 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_164 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_380 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_626 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_912 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_938 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_888 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_303 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_316 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_157 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_584 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_732 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_903 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_328 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_53 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_275_433 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_3 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_29 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_81 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_55 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_26 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_0 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_78 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_52 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_14 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_40 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_92 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_66 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_97 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_71 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_19 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_45 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_27 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_79 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_1 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_53 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_43 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_17 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_95 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_69 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_13 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_91 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_39 !\n", + "25/07/30 16:35:07 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_65 !\n", + "25/07/30 16:35:11 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_28 !\n", + "25/07/30 16:35:11 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_54 !\n", + "25/07/30 16:35:11 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_80 !\n", + "25/07/30 16:35:11 WARN BlockManagerMasterEndpoint: No more replicas available for rdd_322_2 !\n" ] } ], @@ -36103,6 +37213,17 @@ " SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash\n", " )" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1502101a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "spark." + ] } ], "metadata": { -- GitLab From 0a6dd230fd053ea081424ced57b3d7c4ba70fcd1 Mon Sep 17 00:00:00 2001 From: ozge Date: Thu, 31 Jul 2025 10:20:48 +0200 Subject: [PATCH 09/13] feat: adds addalink steps --- training/add_a_link/pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/training/add_a_link/pyproject.toml b/training/add_a_link/pyproject.toml index 070ca2e..5c44348 100644 --- a/training/add_a_link/pyproject.toml +++ b/training/add_a_link/pyproject.toml @@ -12,7 +12,7 @@ dependencies = [ "wikitextparser>=0.55.13", "pyicu>=2.9", "python-Levenshtein>=0.20.8", - "pyarrow>=18.1.0", + "pyarrow==21.0.0", "mwparserfromhell>=0.6.5", "numpy==1.24.4", "pandas==1.5.3", @@ -22,7 +22,7 @@ dependencies = [ "scikit-learn==1.0.2", "ipykernel==6.29.5", "research-common @ git+https://gitlab.wikimedia.org/repos/research/research-common.git@v0.2.0", - "fsspec==2025.7.0", + "fsspec[arrow]==2025.7.0", ] [project.optional-dependencies] -- GitLab From 63f9707f2cf121320ec879ca7cfa9b43e763f2b2 Mon Sep 17 00:00:00 2001 From: ozge Date: Thu, 31 Jul 2025 11:03:10 +0200 Subject: [PATCH 10/13] feat: adds addalink steps --- training/add_a_link/src/add_a_link/generate_addlink_model.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py index ed78949..36b5d60 100644 --- a/training/add_a_link/src/add_a_link/generate_addlink_model.py +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -113,7 +113,8 @@ def run( # noqa: PLR0915 :param grid_search: Whether to perform grid search and store best model """ print("Number of Wikis:", len(wiki_dbs)) - + with fsspec.open("hdfs:///user/ozge/hello2.txt", mode="wt") as f: + f.write("hello") df = pd.DataFrame() if grid_search: -- GitLab From 36a685d0633d99f040c5a264fa438dc025eb8ce9 Mon Sep 17 00:00:00 2001 From: ozge Date: Thu, 31 Jul 2025 12:16:46 +0200 Subject: [PATCH 11/13] feat: adds addalink steps --- .../src/add_a_link/generate_addlink_model.py | 3 +- .../add_a_link/generate_backtesting_eval.py | 3 +- .../add_a_link/notebooks/pipeline_run.ipynb | 215 +++++++++++++++++- training/add_a_link/src/add_a_link/utils.py | 12 +- 4 files changed, 219 insertions(+), 14 deletions(-) diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py index 36b5d60..b380c9c 100644 --- a/training/add_a_link/src/add_a_link/generate_addlink_model.py +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -19,11 +19,12 @@ from sklearn.model_selection import ( # type: ignore[import-untyped] ) from sklearn.preprocessing import OrdinalEncoder # type: ignore[import-untyped] -from add_a_link.utils import hdfs_path +from add_a_link.utils import hdfs_path, configure_fsspec seed = 7 max_train_samples = 10_000_000 # for combined model max_train_samples_grid = 50000 # for grid_search +configure_fsspec() def get_training_data( diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py index 56708ae..2c8f7cb 100644 --- a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py +++ b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py @@ -18,9 +18,10 @@ from add_a_link.utils import ( getLinks, hdfs_path, process_page, + configure_fsspec ) - +configure_fsspec() def to_dict(df: DataFrame, key_col: str, value_col: str) -> dict[str, Any]: any_dict = ( df.select(key_col, value_col).toPandas().set_index(key_col)[value_col].to_dict() diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index f8bcc43..4dc6326 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "f68aa58e", "metadata": {}, "outputs": [], @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "7d6412c6", "metadata": { "ExecuteTime": { @@ -26,7 +26,27 @@ } }, "outputs": [], - "source": [] + "source": [ + "import os\n", + "import subprocess\n", + "import fsspec\n", + "def configure_fsspec() -> None:\n", + " os.environ[\"CLASSPATH\"] = (\n", + " subprocess.check_output([\"hadoop\", \"classpath\", \"--glob\"])\n", + " .decode(\"utf-8\")\n", + " .strip()\n", + " )\n", + " os.environ[\"JAVA_HOME\"] = \"/usr/lib/jvm/java-1.8.0-openjdk-amd64\"\n", + " os.environ[\"HADOOP_HOME\"] = \"/usr/lib/hadoop\"\n", + "\n", + "\n", + "configure_fsspec()\n", + "\n", + "\n", + "fs = fsspec.filesystem(\"hdfs\") \n", + "with fs.open(\"/user/ozge/13hello.txt\", \"wt\") as f:\n", + " f.write(\"hello\")" + ] }, { "cell_type": "code", @@ -37204,26 +37224,199 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "id": "c2b282bc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 3 items\n", + "drwxr-x--- - ozge ozge 0 2025-07-21 13:49 /user/ozge/test_addalink_ml_airflow/trwiki/anchors\n", + "drwxr-x--- - ozge ozge 0 2025-07-21 13:29 /user/ozge/test_addalink_ml_airflow/trwiki/pageids\n", + "drwxr-x--- - ozge ozge 0 2025-07-21 13:29 /user/ozge/test_addalink_ml_airflow/trwiki/redirects\n" + ] + } + ], "source": [ - "anchors = rbloom.Bloom.load(\n", - " SparkFiles.get(f\"anchor_{model_id}.bloom\"), compute_hash\n", - " )" + "!hdfs dfs -ls /user/ozge/test_addalink_ml_airflow/trwiki" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "1502101a", "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Environment variable CLASSPATH not set!\n", + "getJNIEnv: getGlobalJNIEnv failed\n", + "Environment variable CLASSPATH not set!\n", + "getJNIEnv: getGlobalJNIEnv failed\n", + "WARNING: Logging before InitGoogleLogging() is written to STDERR\n", + "W20250731 07:59:02.179745 140689381184128 status.cc:168] Failed to disconnect hdfs client: IOError: HDFS hdfsFS::Disconnect failed. Detail: [errno 255] Unknown error 255\n" + ] + }, + { + "ename": "OSError", + "evalue": "HDFS connection failed", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mjoblib\u001b[39;00m \u001b[38;5;66;03m# type: ignore[import-untyped]\u001b[39;00m\n\u001b[1;32m 3\u001b[0m model \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m----> 4\u001b[0m fs \u001b[38;5;241m=\u001b[39m \u001b[43mfsspec\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfilesystem\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhdfs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mhost\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhdfs://analytics-hadoop/\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mport\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m8020\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m link_model_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/user/ozge/test_addalink_ml_airflow/trwiki/linkmodel.joblib\u001b[39m\u001b[38;5;124m\"\u001b[39m \n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m fs\u001b[38;5;241m.\u001b[39mopen(link_model_path, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwb\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m file:\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/registry.py:322\u001b[0m, in \u001b[0;36mfilesystem\u001b[0;34m(protocol, **storage_options)\u001b[0m\n\u001b[1;32m 315\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 316\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marrow_hdfs\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m protocol has been deprecated and will be \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mremoved in the future. Specify it as \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhdfs\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 318\u001b[0m \u001b[38;5;167;01mDeprecationWarning\u001b[39;00m,\n\u001b[1;32m 319\u001b[0m )\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28mcls\u001b[39m \u001b[38;5;241m=\u001b[39m get_filesystem_class(protocol)\n\u001b[0;32m--> 322\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mstorage_options\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/spec.py:81\u001b[0m, in \u001b[0;36m_Cached.__call__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_cache[token]\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 81\u001b[0m obj \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;66;03m# Setting _fs_token here causes some static linters to complain.\u001b[39;00m\n\u001b[1;32m 83\u001b[0m obj\u001b[38;5;241m.\u001b[39m_fs_token_ \u001b[38;5;241m=\u001b[39m token\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/implementations/arrow.py:280\u001b[0m, in \u001b[0;36mHadoopFileSystem.__init__\u001b[0;34m(self, host, port, user, kerb_ticket, replication, extra_conf, **kwargs)\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 262\u001b[0m \n\u001b[1;32m 263\u001b[0m \u001b[38;5;124;03mParameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;124;03m Passed on to HadoopFileSystem\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 278\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpyarrow\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfs\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m HadoopFileSystem\n\u001b[0;32m--> 280\u001b[0m fs \u001b[38;5;241m=\u001b[39m \u001b[43mHadoopFileSystem\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[43m \u001b[49m\u001b[43mhost\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhost\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 282\u001b[0m \u001b[43m \u001b[49m\u001b[43mport\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mport\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 283\u001b[0m \u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[43m \u001b[49m\u001b[43mkerb_ticket\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkerb_ticket\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 285\u001b[0m \u001b[43m \u001b[49m\u001b[43mreplication\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreplication\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_conf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_conf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 288\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(fs\u001b[38;5;241m=\u001b[39mfs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/_hdfs.pyx:97\u001b[0m, in \u001b[0;36mpyarrow._hdfs.HadoopFileSystem.__init__\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/error.pxi:155\u001b[0m, in \u001b[0;36mpyarrow.lib.pyarrow_internal_check_status\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/error.pxi:92\u001b[0m, in \u001b[0;36mpyarrow.lib.check_status\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mOSError\u001b[0m: HDFS connection failed" + ] + } + ], + "source": [ + "import fsspec # type: ignore[import-untyped]\n", + "import joblib # type: ignore[import-untyped]\n", + "model = {}\n", + "fs = fsspec.filesystem(\"hdfs\", host=\"hdfs://analytics-hadoop/\", port=8020)\n", + "link_model_path = \"/user/ozge/test_addalink_ml_airflow/trwiki/linkmodel.joblib\" \n", + "with fs.open(link_model_path, \"wb\") as file:\n", + " joblib.dump(model, file)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9ea33d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 7 items\n", + "drwx------ - ozge ozge 0 2025-07-31 00:00 hdfs://analytics-hadoop:8020/user/ozge/.Trash\n", + "drwxr-x--- - ozge ozge 0 2025-07-30 18:59 hdfs://analytics-hadoop:8020/user/ozge/.skein\n", + "drwxr-x--- - ozge ozge 0 2025-07-30 18:59 hdfs://analytics-hadoop:8020/user/ozge/.sparkStaging\n", + "drwxr-x--- - ozge ozge 0 2025-07-30 11:28 hdfs://analytics-hadoop:8020/user/ozge/temp\n", + "drwxr-x--- - ozge ozge 0 2025-07-02 10:34 hdfs://analytics-hadoop:8020/user/ozge/test_addalink\n", + "drwxr-x--- - ozge ozge 0 2025-07-18 06:28 hdfs://analytics-hadoop:8020/user/ozge/test_addalink_ml\n", + "drwxr-x--- - ozge ozge 0 2025-07-21 13:27 hdfs://analytics-hadoop:8020/user/ozge/test_addalink_ml_airflow\n" + ] + } + ], + "source": [ + "!hdfs dfs -ls hdfs://analytics-hadoop:8020/user/ozge/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e03b14a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Environment variable CLASSPATH not set!\n", + "getJNIEnv: getGlobalJNIEnv failed\n", + "Environment variable CLASSPATH not set!\n", + "getJNIEnv: getGlobalJNIEnv failed\n", + "W20250731 08:14:27.428965 140689381184128 status.cc:168] Failed to disconnect hdfs client: IOError: HDFS hdfsFS::Disconnect failed. Detail: [errno 255] Unknown error 255\n" + ] + }, + { + "ename": "OSError", + "evalue": "HDFS connection failed", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mOSError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[43mfsspec\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfilesystem\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhdfs\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m fs:\n\u001b[1;32m 2\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m fs\u001b[38;5;241m.\u001b[39mopen(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m/user/ozge/hello.txt\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwt\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[1;32m 3\u001b[0m f\u001b[38;5;241m.\u001b[39mwrite(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhello\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/registry.py:322\u001b[0m, in \u001b[0;36mfilesystem\u001b[0;34m(protocol, **storage_options)\u001b[0m\n\u001b[1;32m 315\u001b[0m warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[1;32m 316\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124marrow_hdfs\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m protocol has been deprecated and will be \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mremoved in the future. Specify it as \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhdfs\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 318\u001b[0m \u001b[38;5;167;01mDeprecationWarning\u001b[39;00m,\n\u001b[1;32m 319\u001b[0m )\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28mcls\u001b[39m \u001b[38;5;241m=\u001b[39m get_filesystem_class(protocol)\n\u001b[0;32m--> 322\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mstorage_options\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/spec.py:81\u001b[0m, in \u001b[0;36m_Cached.__call__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m_cache[token]\n\u001b[1;32m 80\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 81\u001b[0m obj \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;66;03m# Setting _fs_token here causes some static linters to complain.\u001b[39;00m\n\u001b[1;32m 83\u001b[0m obj\u001b[38;5;241m.\u001b[39m_fs_token_ \u001b[38;5;241m=\u001b[39m token\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/fsspec/implementations/arrow.py:280\u001b[0m, in \u001b[0;36mHadoopFileSystem.__init__\u001b[0;34m(self, host, port, user, kerb_ticket, replication, extra_conf, **kwargs)\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 262\u001b[0m \n\u001b[1;32m 263\u001b[0m \u001b[38;5;124;03mParameters\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[38;5;124;03m Passed on to HadoopFileSystem\u001b[39;00m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 278\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpyarrow\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mfs\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m HadoopFileSystem\n\u001b[0;32m--> 280\u001b[0m fs \u001b[38;5;241m=\u001b[39m \u001b[43mHadoopFileSystem\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 281\u001b[0m \u001b[43m \u001b[49m\u001b[43mhost\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhost\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 282\u001b[0m \u001b[43m \u001b[49m\u001b[43mport\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mport\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 283\u001b[0m \u001b[43m \u001b[49m\u001b[43muser\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muser\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[43m \u001b[49m\u001b[43mkerb_ticket\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkerb_ticket\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 285\u001b[0m \u001b[43m \u001b[49m\u001b[43mreplication\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreplication\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[43m \u001b[49m\u001b[43mextra_conf\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_conf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 287\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 288\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(fs\u001b[38;5;241m=\u001b[39mfs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/_hdfs.pyx:97\u001b[0m, in \u001b[0;36mpyarrow._hdfs.HadoopFileSystem.__init__\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/error.pxi:155\u001b[0m, in \u001b[0;36mpyarrow.lib.pyarrow_internal_check_status\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m~/.conda/envs/add_a_link/lib/python3.10/site-packages/pyarrow/error.pxi:92\u001b[0m, in \u001b[0;36mpyarrow.lib.check_status\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mOSError\u001b[0m: HDFS connection failed" + ] + } + ], + "source": [ + "import fsspec\n", + "with fsspec.filesystem(\"hdfs\") as fs:\n", + " with fs.open(\"/user/ozge/hello.txt\", \"wt\") as f:\n", + " f.write(\"hello\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2521dbe6", + "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "spark." + "! pip list | grep fsspec" ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "90844892", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pyarrow 9.0.0\n" + ] + } + ], + "source": [ + "! pip list | grep pyarrow" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4798af5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 8 items\n", + "drwx------ - ozge ozge 0 2025-07-31 00:00 /user/ozge/.Trash\n", + "drwxr-x--- - ozge ozge 0 2025-07-31 09:15 /user/ozge/.skein\n", + "drwxr-x--- - ozge ozge 0 2025-07-31 09:15 /user/ozge/.sparkStaging\n", + "-rw-r----- 3 ozge ozge 5 2025-07-31 08:31 /user/ozge/hello.txt\n", + "drwxr-x--- - ozge ozge 0 2025-07-30 11:28 /user/ozge/temp\n", + "drwxr-x--- - ozge ozge 0 2025-07-02 10:34 /user/ozge/test_addalink\n", + "drwxr-x--- - ozge ozge 0 2025-07-18 06:28 /user/ozge/test_addalink_ml\n", + "drwxr-x--- - ozge ozge 0 2025-07-21 13:27 /user/ozge/test_addalink_ml_airflow\n" + ] + } + ], + "source": [ + "!hdfs dfs -ls /user/ozge/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "465cd9c2", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/training/add_a_link/src/add_a_link/utils.py b/training/add_a_link/src/add_a_link/utils.py index 6b3b560..f924f55 100644 --- a/training/add_a_link/src/add_a_link/utils.py +++ b/training/add_a_link/src/add_a_link/utils.py @@ -6,7 +6,8 @@ import time import urllib.parse as up from collections.abc import Generator from typing import Any, cast - +import os +import subprocess import mwparserfromhell # type: ignore[import-untyped] import numpy as np import requests @@ -28,6 +29,15 @@ from add_a_link.ngram_utils import ( FREQUENCY = 10 +def configure_fsspec() -> None: + os.environ["CLASSPATH"] = ( + subprocess.check_output(["hadoop", "classpath", "--glob"]) + .decode("utf-8") + .strip() + ) + os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-1.8.0-openjdk-amd64" + os.environ["HADOOP_HOME"] = "/usr/lib/hadoop" + def hdfs_path(path: pathlib.Path) -> str: return f"hdfs://analytics-hadoop{path}" -- GitLab From f72e5500e7088a5d61a7d4506c380abbb6c5a0af Mon Sep 17 00:00:00 2001 From: ozge Date: Thu, 31 Jul 2025 12:39:01 +0200 Subject: [PATCH 12/13] feat: adds addalink steps --- .../src/add_a_link/generate_addlink_model.py | 7 +++---- .../src/add_a_link/generate_backtesting_eval.py | 4 +++- .../src/add_a_link/generate_training_data.py | 16 ++++++++++------ .../src/add_a_link/notebooks/pipeline_run.ipynb | 16 +++++----------- training/add_a_link/src/add_a_link/utils.py | 6 ++++-- 5 files changed, 25 insertions(+), 24 deletions(-) diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py index b380c9c..976fc54 100644 --- a/training/add_a_link/src/add_a_link/generate_addlink_model.py +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -1,12 +1,13 @@ import multiprocessing import pathlib from collections.abc import Sequence -from pyspark.sql import SparkSession + import click import fsspec # type: ignore[import-untyped] import joblib # type: ignore[import-untyped] import pandas as pd import xgboost +from pyspark.sql import SparkSession from sklearn import model_selection # type: ignore[import-untyped] from sklearn.metrics import ( # type: ignore[import-untyped] average_precision_score, @@ -19,7 +20,7 @@ from sklearn.model_selection import ( # type: ignore[import-untyped] ) from sklearn.preprocessing import OrdinalEncoder # type: ignore[import-untyped] -from add_a_link.utils import hdfs_path, configure_fsspec +from add_a_link.utils import configure_fsspec, hdfs_path seed = 7 max_train_samples = 10_000_000 # for combined model @@ -114,8 +115,6 @@ def run( # noqa: PLR0915 :param grid_search: Whether to perform grid search and store best model """ print("Number of Wikis:", len(wiki_dbs)) - with fsspec.open("hdfs:///user/ozge/hello2.txt", mode="wt") as f: - f.write("hello") df = pd.DataFrame() if grid_search: diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py index 2c8f7cb..fb7409c 100644 --- a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py +++ b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py @@ -13,15 +13,17 @@ from mwtokenizer import Tokenizer # type: ignore[import-untyped] from pyspark.sql import DataFrame, SparkSession, functions as F from add_a_link.utils import ( + configure_fsspec, get_language_code, get_wiki_url, getLinks, hdfs_path, process_page, - configure_fsspec ) configure_fsspec() + + def to_dict(df: DataFrame, key_col: str, value_col: str) -> dict[str, Any]: any_dict = ( df.select(key_col, value_col).toPandas().set_index(key_col)[value_col].to_dict() diff --git a/training/add_a_link/src/add_a_link/generate_training_data.py b/training/add_a_link/src/add_a_link/generate_training_data.py index d260cc0..e030c21 100644 --- a/training/add_a_link/src/add_a_link/generate_training_data.py +++ b/training/add_a_link/src/add_a_link/generate_training_data.py @@ -1,6 +1,6 @@ import pathlib -from collections.abc import Iterable, Iterator, Sequence import subprocess +from collections.abc import Iterable, Iterator, Sequence import click import mwparserfromhell as mwph # type: ignore[import-untyped] @@ -124,9 +124,7 @@ def enrich_with_candidate_anchors( ) -> Iterator[pd.DataFrame]: # Load the bloom filter containing all known anchors ahead of # processing any batches so we only load it once. - anchors = rbloom.Bloom.load( - SparkFiles.get(anchors_file.name), compute_hash - ) + anchors = rbloom.Bloom.load(SparkFiles.get(anchors_file.name), compute_hash) for batch in sentence_batches: batch["anchor"] = [ @@ -354,12 +352,18 @@ def run( """ anchors_file = pathlib.Path.cwd() / f"anchor_{model_id}.bloom" subprocess.run( - ["hdfs", "dfs", "-get", str(directory / f"anchor_{model_id}.bloom"), str(anchors_file)], + [ + "hdfs", + "dfs", + "-get", + str(directory / f"anchor_{model_id}.bloom"), + str(anchors_file), + ], check=True, capture_output=True, text=True, ) - + anchors_df = spark.read.parquet(str(directory / "anchors_filtered")) pageids_df = ( spark.read.parquet(str(directory / "pageids")) diff --git a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb index 4dc6326..e0ef96f 100644 --- a/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb +++ b/training/add_a_link/src/add_a_link/notebooks/pipeline_run.ipynb @@ -35774,7 +35774,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "id": "5821e769", "metadata": {}, "outputs": [ @@ -35782,20 +35782,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 8 items\n", - "-rw-r----- 3 ozge hdfs 59906623 2025-07-30 12:39 /tmp/ozge/addalink/shard_nl/anchor_shard_nl.bloom\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 12:35 /tmp/ozge/addalink/shard_nl/anchors\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 10:56 /tmp/ozge/addalink/shard_nl/anchors_filtered\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 12:17 /tmp/ozge/addalink/shard_nl/pageids\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 12:17 /tmp/ozge/addalink/shard_nl/redirects\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 11:03 /tmp/ozge/addalink/shard_nl/testing\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 10:57 /tmp/ozge/addalink/shard_nl/training\n", - "drwxr-x--- - ozge hdfs 0 2025-07-30 10:54 /tmp/ozge/addalink/shard_nl/wdproperties\n" + "Found 2 items\n", + "-rw-r----- 3 ozge hdfs 619 2025-07-31 10:28 /tmp/ozge/addalink/shard_nl/shard_nl/shard_nl.encoder.joblib\n", + "-rw-r----- 3 ozge hdfs 2896879 2025-07-31 10:28 /tmp/ozge/addalink/shard_nl/shard_nl/shard_nl.linkmodel.joblib\n" ] } ], "source": [ - "!hdfs dfs -ls /tmp/ozge/addalink/shard_nl/" + "!hdfs dfs -ls /tmp/ozge/addalink/shard_nl/shard_nl" ] }, { diff --git a/training/add_a_link/src/add_a_link/utils.py b/training/add_a_link/src/add_a_link/utils.py index f924f55..28b0a1d 100644 --- a/training/add_a_link/src/add_a_link/utils.py +++ b/training/add_a_link/src/add_a_link/utils.py @@ -1,13 +1,14 @@ import functools import operator +import os import pathlib import re +import subprocess import time import urllib.parse as up from collections.abc import Generator from typing import Any, cast -import os -import subprocess + import mwparserfromhell # type: ignore[import-untyped] import numpy as np import requests @@ -29,6 +30,7 @@ from add_a_link.ngram_utils import ( FREQUENCY = 10 + def configure_fsspec() -> None: os.environ["CLASSPATH"] = ( subprocess.check_output(["hadoop", "classpath", "--glob"]) -- GitLab From 50c838765c2b7e45b0cfc3b282a01709d736c9ac Mon Sep 17 00:00:00 2001 From: ozge Date: Thu, 31 Jul 2025 13:39:46 +0200 Subject: [PATCH 13/13] feat: adds addalink steps --- training/add_a_link/.gitlab-ci.yml | 14 +++++++------- .../src/add_a_link/generate_addlink_model.py | 2 +- .../src/add_a_link/generate_backtesting_eval.py | 4 +--- 3 files changed, 9 insertions(+), 11 deletions(-) diff --git a/training/add_a_link/.gitlab-ci.yml b/training/add_a_link/.gitlab-ci.yml index b03a92b..519c7ef 100644 --- a/training/add_a_link/.gitlab-ci.yml +++ b/training/add_a_link/.gitlab-ci.yml @@ -5,7 +5,7 @@ default: stages: - # - test + - test - deploy @@ -41,9 +41,9 @@ publish_conda_env: - if: $CI_COMMIT_TAG when: on_success -# pytest: -# stage: test -# extends: .job_template -# script: -# - pytest ../../tests/training/add_a_link -# when: always \ No newline at end of file +pytest: + stage: test + extends: .job_template + script: + - pytest ../../tests/training/add_a_link + when: always \ No newline at end of file diff --git a/training/add_a_link/src/add_a_link/generate_addlink_model.py b/training/add_a_link/src/add_a_link/generate_addlink_model.py index 976fc54..a783e6a 100644 --- a/training/add_a_link/src/add_a_link/generate_addlink_model.py +++ b/training/add_a_link/src/add_a_link/generate_addlink_model.py @@ -25,7 +25,6 @@ from add_a_link.utils import configure_fsspec, hdfs_path seed = 7 max_train_samples = 10_000_000 # for combined model max_train_samples_grid = 50000 # for grid_search -configure_fsspec() def get_training_data( @@ -115,6 +114,7 @@ def run( # noqa: PLR0915 :param grid_search: Whether to perform grid search and store best model """ print("Number of Wikis:", len(wiki_dbs)) + configure_fsspec() df = pd.DataFrame() if grid_search: diff --git a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py index fb7409c..8c3c814 100644 --- a/training/add_a_link/src/add_a_link/generate_backtesting_eval.py +++ b/training/add_a_link/src/add_a_link/generate_backtesting_eval.py @@ -21,8 +21,6 @@ from add_a_link.utils import ( process_page, ) -configure_fsspec() - def to_dict(df: DataFrame, key_col: str, value_col: str) -> dict[str, Any]: any_dict = ( @@ -51,7 +49,7 @@ def run( # noqa: PLR0915 :param directory: Path to output directory :param n_max: Maximum number of sentences to evaluate """ - + configure_fsspec() anchors_df = ( spark.read.parquet(str(directory / "anchors_filtered")) .where(F.col("wiki_db").isin(*wiki_dbs)) -- GitLab