4ec04e5ef3
## What changes were proposed in this pull request?
This PR proposes to add **Single threading model design (pinned thread model)** mode which is an experimental mode to sync threads on PVM and JVM. See https://www.py4j.org/advanced_topics.html#using-single-threading-model-pinned-thread
### Multi threading model
Currently, PySpark uses this model. Threads on PVM and JVM are independent. For instance, in a different Python thread, callbacks are received and relevant Python codes are executed. JVM threads are reused when possible.
Py4J will create a new thread every time a command is received and there is no thread available. See the current model we're using - https://www.py4j.org/advanced_topics.html#the-multi-threading-model
One problem in this model is that we can't sync threads on PVM and JVM out of the box. This leads to some problems in particular at some codes related to threading in JVM side. See:
7056e004ee/core/src/main/scala/org/apache/spark/SparkContext.scala (L334)
Due to reusing JVM threads, seems the job groups in Python threads cannot be set in each thread as described in the JIRA.
### Single threading model design (pinned thread model)
This mode pins and syncs the threads on PVM and JVM to work around the problem above. For instance, in the same Python thread, callbacks are received and relevant Python codes are executed. See https://www.py4j.org/advanced_topics.html#the-single-threading-model
Even though this mode can sync threads on PVM and JVM for other thread related code paths,
this might cause another problem: seems unable to inherit properties as below (assuming multi-thread mode still creates new threads when existing threads are busy, I suspect this issue already exists when multiple jobs are submitted in multi-thread mode; however, it can be always seen in single threading mode):
```bash
$ PYSPARK_PIN_THREAD=true ./bin/pyspark
```
```python
import threading
spark.sparkContext.setLocalProperty("a", "hi")
def print_prop():
print(spark.sparkContext.getLocalProperty("a"))
threading.Thread(target=print_prop).start()
```
```
None
```
Unlike Scala side:
```scala
spark.sparkContext.setLocalProperty("a", "hi")
new Thread(new Runnable {
def run() = println(spark.sparkContext.getLocalProperty("a"))
}).start()
```
```
hi
```
This behaviour potentially could cause weird issues but this PR currently does not target this fix this for now since this mode is experimental.
### How does this PR fix?
Basically there are two types of Py4J servers `GatewayServer` and `ClientServer`. The former is for multi threading and the latter is for single threading. This PR adds a switch to use the latter.
In Scala side:
The logic to select a server is encapsulated in `Py4JServer` and use `Py4JServer` at `PythonRunner` for Spark summit and `PythonGatewayServer` for Spark shell. Each uses `ClientServer` when `PYSPARK_PIN_THREAD` is `true` and `GatewayServer` otherwise.
In Python side:
Simply do an if-else to switch the server to talk. It uses `ClientServer` when `PYSPARK_PIN_THREAD` is `true` and `GatewayServer` otherwise.
This is disabled by default for now.
## How was this patch tested?
Manually tested. This can be tested via:
```python
PYSPARK_PIN_THREAD=true ./bin/pyspark
```
and/or
```bash
cd python
./run-tests --python-executables=python --testnames "pyspark.tests.test_pin_thread"
```
Also, ran the Jenkins tests with `PYSPARK_PIN_THREAD` enabled.
Closes #24898 from HyukjinKwon/pinned-thread.
Authored-by: HyukjinKwon <gurwls223@apache.org>
Signed-off-by: HyukjinKwon <gurwls223@apache.org>
128 lines
5.3 KiB
Python
128 lines
5.3 KiB
Python
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one or more
|
|
# contributor license agreements. See the NOTICE file distributed with
|
|
# this work for additional information regarding copyright ownership.
|
|
# The ASF licenses this file to You under the Apache License, Version 2.0
|
|
# (the "License"); you may not use this file except in compliance with
|
|
# the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
import unittest
|
|
|
|
import py4j
|
|
|
|
from pyspark.ml.linalg import DenseVector, Vectors
|
|
from pyspark.ml.regression import LinearRegression
|
|
from pyspark.ml.wrapper import _java2py, _py2java, JavaParams, JavaWrapper
|
|
from pyspark.testing.mllibutils import MLlibTestCase
|
|
from pyspark.testing.mlutils import SparkSessionTestCase
|
|
from pyspark.testing.utils import eventually
|
|
|
|
|
|
class JavaWrapperMemoryTests(SparkSessionTestCase):
|
|
|
|
def test_java_object_gets_detached(self):
|
|
df = self.spark.createDataFrame([(1.0, 2.0, Vectors.dense(1.0)),
|
|
(0.0, 2.0, Vectors.sparse(1, [], []))],
|
|
["label", "weight", "features"])
|
|
lr = LinearRegression(maxIter=1, regParam=0.0, solver="normal", weightCol="weight",
|
|
fitIntercept=False)
|
|
|
|
model = lr.fit(df)
|
|
summary = model.summary
|
|
|
|
self.assertIsInstance(model, JavaWrapper)
|
|
self.assertIsInstance(summary, JavaWrapper)
|
|
self.assertIsInstance(model, JavaParams)
|
|
self.assertNotIsInstance(summary, JavaParams)
|
|
|
|
error_no_object = 'Target Object ID does not exist for this gateway'
|
|
|
|
self.assertIn("LinearRegression_", model._java_obj.toString())
|
|
self.assertIn("LinearRegressionTrainingSummary", summary._java_obj.toString())
|
|
|
|
model.__del__()
|
|
|
|
def condition():
|
|
with self.assertRaisesRegexp(py4j.protocol.Py4JError, error_no_object):
|
|
model._java_obj.toString()
|
|
self.assertIn("LinearRegressionTrainingSummary", summary._java_obj.toString())
|
|
return True
|
|
|
|
eventually(condition, timeout=10, catch_assertions=True)
|
|
|
|
try:
|
|
summary.__del__()
|
|
except:
|
|
pass
|
|
|
|
def condition():
|
|
with self.assertRaisesRegexp(py4j.protocol.Py4JError, error_no_object):
|
|
model._java_obj.toString()
|
|
with self.assertRaisesRegexp(py4j.protocol.Py4JError, error_no_object):
|
|
summary._java_obj.toString()
|
|
return True
|
|
|
|
eventually(condition, timeout=10, catch_assertions=True)
|
|
|
|
|
|
class WrapperTests(MLlibTestCase):
|
|
|
|
def test_new_java_array(self):
|
|
# test array of strings
|
|
str_list = ["a", "b", "c"]
|
|
java_class = self.sc._gateway.jvm.java.lang.String
|
|
java_array = JavaWrapper._new_java_array(str_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), str_list)
|
|
# test array of integers
|
|
int_list = [1, 2, 3]
|
|
java_class = self.sc._gateway.jvm.java.lang.Integer
|
|
java_array = JavaWrapper._new_java_array(int_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), int_list)
|
|
# test array of floats
|
|
float_list = [0.1, 0.2, 0.3]
|
|
java_class = self.sc._gateway.jvm.java.lang.Double
|
|
java_array = JavaWrapper._new_java_array(float_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), float_list)
|
|
# test array of bools
|
|
bool_list = [False, True, True]
|
|
java_class = self.sc._gateway.jvm.java.lang.Boolean
|
|
java_array = JavaWrapper._new_java_array(bool_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), bool_list)
|
|
# test array of Java DenseVectors
|
|
v1 = DenseVector([0.0, 1.0])
|
|
v2 = DenseVector([1.0, 0.0])
|
|
vec_java_list = [_py2java(self.sc, v1), _py2java(self.sc, v2)]
|
|
java_class = self.sc._gateway.jvm.org.apache.spark.ml.linalg.DenseVector
|
|
java_array = JavaWrapper._new_java_array(vec_java_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), [v1, v2])
|
|
# test empty array
|
|
java_class = self.sc._gateway.jvm.java.lang.Integer
|
|
java_array = JavaWrapper._new_java_array([], java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), [])
|
|
# test array of array of strings
|
|
str_list = [["a", "b", "c"], ["d", "e"], ["f", "g", "h", "i"], []]
|
|
expected_str_list = [("a", "b", "c", None), ("d", "e", None, None), ("f", "g", "h", "i"),
|
|
(None, None, None, None)]
|
|
java_class = self.sc._gateway.jvm.java.lang.String
|
|
java_array = JavaWrapper._new_java_array(str_list, java_class)
|
|
self.assertEqual(_java2py(self.sc, java_array), expected_str_list)
|
|
|
|
if __name__ == "__main__":
|
|
from pyspark.ml.tests.test_wrapper import *
|
|
|
|
try:
|
|
import xmlrunner
|
|
testRunner = xmlrunner.XMLTestRunner(output='target/test-reports', verbosity=2)
|
|
except ImportError:
|
|
testRunner = None
|
|
unittest.main(testRunner=testRunner, verbosity=2)
|