From 886b39de557b4d5f54f5ca11559fca9799534280 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 10 Aug 2012 01:10:02 -0700 Subject: [PATCH 01/85] Add Python API. --- .../scala/spark/api/python/PythonRDD.scala | 147 +++++ pyspark/pyspark/__init__.py | 0 pyspark/pyspark/context.py | 69 +++ pyspark/pyspark/examples/__init__.py | 0 pyspark/pyspark/examples/kmeans.py | 56 ++ pyspark/pyspark/examples/pi.py | 20 + pyspark/pyspark/examples/tc.py | 49 ++ pyspark/pyspark/java_gateway.py | 20 + pyspark/pyspark/join.py | 104 ++++ pyspark/pyspark/rdd.py | 517 ++++++++++++++++++ pyspark/pyspark/serializers.py | 229 ++++++++ pyspark/pyspark/worker.py | 97 ++++ pyspark/requirements.txt | 9 + python/tc.py | 22 + 14 files changed, 1339 insertions(+) create mode 100644 core/src/main/scala/spark/api/python/PythonRDD.scala create mode 100644 pyspark/pyspark/__init__.py create mode 100644 pyspark/pyspark/context.py create mode 100644 pyspark/pyspark/examples/__init__.py create mode 100644 pyspark/pyspark/examples/kmeans.py create mode 100644 pyspark/pyspark/examples/pi.py create mode 100644 pyspark/pyspark/examples/tc.py create mode 100644 pyspark/pyspark/java_gateway.py create mode 100644 pyspark/pyspark/join.py create mode 100644 pyspark/pyspark/rdd.py create mode 100644 pyspark/pyspark/serializers.py create mode 100644 pyspark/pyspark/worker.py create mode 100644 pyspark/requirements.txt create mode 100644 python/tc.py diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala new file mode 100644 index 0000000000..660ad48afe --- /dev/null +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -0,0 +1,147 @@ +package spark.api.python + +import java.io.PrintWriter + +import scala.collection.Map +import scala.collection.JavaConversions._ +import scala.io.Source +import spark._ +import api.java.{JavaPairRDD, JavaRDD} +import scala.Some + +trait PythonRDDBase { + def compute[T](split: Split, envVars: Map[String, String], + command: Seq[String], parent: RDD[T], pythonExec: String): Iterator[String]= { + val currentEnvVars = new ProcessBuilder().environment() + val SPARK_HOME = currentEnvVars.get("SPARK_HOME") + + val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) + // Add the environmental variables to the process. + envVars.foreach { + case (variable, value) => currentEnvVars.put(variable, value) + } + + val proc = pb.start() + val env = SparkEnv.get + + // Start a thread to print the process's stderr to ours + new Thread("stderr reader for " + command) { + override def run() { + for (line <- Source.fromInputStream(proc.getErrorStream).getLines) { + System.err.println(line) + } + } + }.start() + + // Start a thread to feed the process input from our parent's iterator + new Thread("stdin writer for " + command) { + override def run() { + SparkEnv.set(env) + val out = new PrintWriter(proc.getOutputStream) + for (elem <- command) { + out.println(elem) + } + for (elem <- parent.iterator(split)) { + out.println(PythonRDD.pythonDump(elem)) + } + out.close() + } + }.start() + + // Return an iterator that read lines from the process's stdout + val lines: Iterator[String] = Source.fromInputStream(proc.getInputStream).getLines + wrapIterator(lines, proc) + } + + def wrapIterator[T](iter: Iterator[T], proc: Process): Iterator[T] = { + return new Iterator[T] { + def next() = iter.next() + + def hasNext = { + if (iter.hasNext) { + true + } else { + val exitStatus = proc.waitFor() + if (exitStatus != 0) { + throw new Exception("Subprocess exited with status " + exitStatus) + } + false + } + } + } + } +} + +class PythonRDD[T: ClassManifest]( + parent: RDD[T], command: Seq[String], envVars: Map[String, String], + preservePartitoning: Boolean, pythonExec: String) + extends RDD[String](parent.context) with PythonRDDBase { + + def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = + this(parent, command, Map(), preservePartitoning, pythonExec) + + // Similar to Runtime.exec(), if we are given a single string, split it into words + // using a standard StringTokenizer (i.e. by spaces) + def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String) = + this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec) + + override def splits = parent.splits + + override val dependencies = List(new OneToOneDependency(parent)) + + override val partitioner = if (preservePartitoning) parent.partitioner else None + + override def compute(split: Split): Iterator[String] = + compute(split, envVars, command, parent, pythonExec) + + val asJavaRDD : JavaRDD[String] = JavaRDD.fromRDD(this) +} + +class PythonPairRDD[T: ClassManifest] ( + parent: RDD[T], command: Seq[String], envVars: Map[String, String], + preservePartitoning: Boolean, pythonExec: String) + extends RDD[(String, String)](parent.context) with PythonRDDBase { + + def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = + this(parent, command, Map(), preservePartitoning, pythonExec) + + // Similar to Runtime.exec(), if we are given a single string, split it into words + // using a standard StringTokenizer (i.e. by spaces) + def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String) = + this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec) + + override def splits = parent.splits + + override val dependencies = List(new OneToOneDependency(parent)) + + override val partitioner = if (preservePartitoning) parent.partitioner else None + + override def compute(split: Split): Iterator[(String, String)] = { + compute(split, envVars, command, parent, pythonExec).grouped(2).map { + case Seq(a, b) => (a, b) + case x => throw new Exception("Unexpected value: " + x) + } + } + + val asJavaPairRDD : JavaPairRDD[String, String] = JavaPairRDD.fromRDD(this) +} + +object PythonRDD { + def pythonDump[T](x: T): String = { + if (x.isInstanceOf[scala.Option[_]]) { + val t = x.asInstanceOf[scala.Option[_]] + t match { + case None => "*" + case Some(z) => pythonDump(z) + } + } else if (x.isInstanceOf[scala.Tuple2[_, _]]) { + val t = x.asInstanceOf[scala.Tuple2[_, _]] + "(" + pythonDump(t._1) + "," + pythonDump(t._2) + ")" + } else if (x.isInstanceOf[java.util.List[_]]) { + val objs = asScalaBuffer(x.asInstanceOf[java.util.List[_]]).map(pythonDump) + "[" + objs.mkString("|") + "]" + } else { + x.toString + } + } +} diff --git a/pyspark/pyspark/__init__.py b/pyspark/pyspark/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py new file mode 100644 index 0000000000..587ab12b5f --- /dev/null +++ b/pyspark/pyspark/context.py @@ -0,0 +1,69 @@ +import os +import atexit +from tempfile import NamedTemporaryFile + +from pyspark.java_gateway import launch_gateway +from pyspark.serializers import JSONSerializer, NopSerializer +from pyspark.rdd import RDD, PairRDD + + +class SparkContext(object): + + gateway = launch_gateway() + jvm = gateway.jvm + python_dump = jvm.spark.api.python.PythonRDD.pythonDump + + def __init__(self, master, name, defaultSerializer=JSONSerializer, + defaultParallelism=None, pythonExec='python'): + self.master = master + self.name = name + self._jsc = self.jvm.JavaSparkContext(master, name) + self.defaultSerializer = defaultSerializer + self.defaultParallelism = \ + defaultParallelism or self._jsc.sc().defaultParallelism() + self.pythonExec = pythonExec + + def __del__(self): + if self._jsc: + self._jsc.stop() + + def stop(self): + self._jsc.stop() + self._jsc = None + + def parallelize(self, c, numSlices=None, serializer=None): + serializer = serializer or self.defaultSerializer + numSlices = numSlices or self.defaultParallelism + # Calling the Java parallelize() method with an ArrayList is too slow, + # because it sends O(n) Py4J commands. As an alternative, serialized + # objects are written to a file and loaded through textFile(). + tempFile = NamedTemporaryFile(delete=False) + tempFile.writelines(serializer.dumps(x) + '\n' for x in c) + tempFile.close() + atexit.register(lambda: os.unlink(tempFile.name)) + return self.textFile(tempFile.name, numSlices, serializer) + + def parallelizePairs(self, c, numSlices=None, keySerializer=None, + valSerializer=None): + """ + >>> sc = SparkContext("local", "test") + >>> rdd = sc.parallelizePairs([(1, 2), (3, 4)]) + >>> rdd.collect() + [(1, 2), (3, 4)] + """ + keySerializer = keySerializer or self.defaultSerializer + valSerializer = valSerializer or self.defaultSerializer + numSlices = numSlices or self.defaultParallelism + tempFile = NamedTemporaryFile(delete=False) + for (k, v) in c: + tempFile.write(keySerializer.dumps(k).rstrip('\r\n') + '\n') + tempFile.write(valSerializer.dumps(v).rstrip('\r\n') + '\n') + tempFile.close() + atexit.register(lambda: os.unlink(tempFile.name)) + jrdd = self.textFile(tempFile.name, numSlices)._pipePairs([], "echo") + return PairRDD(jrdd, self, keySerializer, valSerializer) + + def textFile(self, name, numSlices=None, serializer=NopSerializer): + numSlices = numSlices or self.defaultParallelism + jrdd = self._jsc.textFile(name, numSlices) + return RDD(jrdd, self, serializer) diff --git a/pyspark/pyspark/examples/__init__.py b/pyspark/pyspark/examples/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/pyspark/pyspark/examples/kmeans.py b/pyspark/pyspark/examples/kmeans.py new file mode 100644 index 0000000000..0761d6e395 --- /dev/null +++ b/pyspark/pyspark/examples/kmeans.py @@ -0,0 +1,56 @@ +import sys + +from pyspark.context import SparkContext + + +def parseVector(line): + return [float(x) for x in line.split(' ')] + + +def addVec(x, y): + return [a + b for (a, b) in zip(x, y)] + + +def squaredDist(x, y): + return sum((a - b) ** 2 for (a, b) in zip(x, y)) + + +def closestPoint(p, centers): + bestIndex = 0 + closest = float("+inf") + for i in range(len(centers)): + tempDist = squaredDist(p, centers[i]) + if tempDist < closest: + closest = tempDist + bestIndex = i + return bestIndex + + +if __name__ == "__main__": + if len(sys.argv) < 5: + print >> sys.stderr, \ + "Usage: PythonKMeans " + exit(-1) + sc = SparkContext(sys.argv[1], "PythonKMeans") + lines = sc.textFile(sys.argv[2]) + data = lines.map(parseVector).cache() + K = int(sys.argv[3]) + convergeDist = float(sys.argv[4]) + + kPoints = data.takeSample(False, K, 34) + tempDist = 1.0 + + while tempDist > convergeDist: + closest = data.mapPairs( + lambda p : (closestPoint(p, kPoints), (p, 1))) + pointStats = closest.reduceByKey( + lambda (x1, y1), (x2, y2): (addVec(x1, x2), y1 + y2)) + newPoints = pointStats.mapPairs( + lambda (x, (y, z)): (x, [a / z for a in y])).collect() + + tempDist = sum(squaredDist(kPoints[x], y) for (x, y) in newPoints) + + for (x, y) in newPoints: + kPoints[x] = y + + print "Final centers: " + str(kPoints) diff --git a/pyspark/pyspark/examples/pi.py b/pyspark/pyspark/examples/pi.py new file mode 100644 index 0000000000..ad77694c41 --- /dev/null +++ b/pyspark/pyspark/examples/pi.py @@ -0,0 +1,20 @@ +import sys +from random import random +from operator import add +from pyspark.context import SparkContext + + +if __name__ == "__main__": + if len(sys.argv) == 1: + print >> sys.stderr, \ + "Usage: PythonPi []" + exit(-1) + sc = SparkContext(sys.argv[1], "PythonKMeans") + slices = sys.argv[2] if len(sys.argv) > 2 else 2 + n = 100000 * slices + def f(_): + x = random() * 2 - 1 + y = random() * 2 - 1 + return 1 if x ** 2 + y ** 2 < 1 else 0 + count = sc.parallelize(xrange(1, n+1), slices).map(f).reduce(add) + print "Pi is roughly %f" % (4.0 * count / n) diff --git a/pyspark/pyspark/examples/tc.py b/pyspark/pyspark/examples/tc.py new file mode 100644 index 0000000000..2796fdc6ad --- /dev/null +++ b/pyspark/pyspark/examples/tc.py @@ -0,0 +1,49 @@ +import sys +from random import Random +from pyspark.context import SparkContext + +numEdges = 200 +numVertices = 100 +rand = Random(42) + + +def generateGraph(): + edges = set() + while len(edges) < numEdges: + src = rand.randrange(0, numEdges) + dst = rand.randrange(0, numEdges) + if src != dst: + edges.add((src, dst)) + return edges + + +if __name__ == "__main__": + if len(sys.argv) == 1: + print >> sys.stderr, \ + "Usage: PythonTC []" + exit(-1) + sc = SparkContext(sys.argv[1], "PythonKMeans") + slices = sys.argv[2] if len(sys.argv) > 2 else 2 + tc = sc.parallelizePairs(generateGraph(), slices).cache() + + # Linear transitive closure: each round grows paths by one edge, + # by joining the graph's edges with the already-discovered paths. + # e.g. join the path (y, z) from the TC with the edge (x, y) from + # the graph to obtain the path (x, z). + + # Because join() joins on keys, the edges are stored in reversed order. + edges = tc.mapPairs(lambda (x, y): (y, x)) + + oldCount = 0L + nextCount = tc.count() + while True: + oldCount = nextCount + # Perform the join, obtaining an RDD of (y, (z, x)) pairs, + # then project the result to obtain the new (x, z) paths. + new_edges = tc.join(edges).mapPairs(lambda (_, (a, b)): (b, a)) + tc = tc.union(new_edges).distinct().cache() + nextCount = tc.count() + if nextCount == oldCount: + break + + print "TC has %i edges" % tc.count() diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py new file mode 100644 index 0000000000..2df80aee85 --- /dev/null +++ b/pyspark/pyspark/java_gateway.py @@ -0,0 +1,20 @@ +import glob +import os +from py4j.java_gateway import java_import, JavaGateway + + +SPARK_HOME = os.environ["SPARK_HOME"] + + +assembly_jar = glob.glob(os.path.join(SPARK_HOME, "core/target") + \ + "/spark-core-assembly-*-SNAPSHOT.jar")[0] + + +def launch_gateway(): + gateway = JavaGateway.launch_gateway(classpath=assembly_jar, + javaopts=["-Xmx256m"], die_on_exit=True) + java_import(gateway.jvm, "spark.api.java.*") + java_import(gateway.jvm, "spark.api.python.*") + java_import(gateway.jvm, "scala.Tuple2") + java_import(gateway.jvm, "spark.api.python.PythonRDD.pythonDump") + return gateway diff --git a/pyspark/pyspark/join.py b/pyspark/pyspark/join.py new file mode 100644 index 0000000000..c67520fce8 --- /dev/null +++ b/pyspark/pyspark/join.py @@ -0,0 +1,104 @@ +""" +Copyright (c) 2011, Douban Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + + * Neither the name of the Douban Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" +from pyspark.serializers import PairSerializer, OptionSerializer, \ + ArraySerializer + + +def _do_python_join(rdd, other, numSplits, dispatch, valSerializer): + vs = rdd.mapPairs(lambda (k, v): (k, (1, v))) + ws = other.mapPairs(lambda (k, v): (k, (2, v))) + return vs.union(ws).groupByKey(numSplits) \ + .flatMapValues(dispatch, valSerializer) + + +def python_join(rdd, other, numSplits): + def dispatch(seq): + vbuf, wbuf = [], [] + for (n, v) in seq: + if n == 1: + vbuf.append(v) + elif n == 2: + wbuf.append(v) + return [(v, w) for v in vbuf for w in wbuf] + valSerializer = PairSerializer(rdd.valSerializer, other.valSerializer) + return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + + +def python_right_outer_join(rdd, other, numSplits): + def dispatch(seq): + vbuf, wbuf = [], [] + for (n, v) in seq: + if n == 1: + vbuf.append(v) + elif n == 2: + wbuf.append(v) + if not vbuf: + vbuf.append(None) + return [(v, w) for v in vbuf for w in wbuf] + valSerializer = PairSerializer(OptionSerializer(rdd.valSerializer), + other.valSerializer) + return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + + +def python_left_outer_join(rdd, other, numSplits): + def dispatch(seq): + vbuf, wbuf = [], [] + for (n, v) in seq: + if n == 1: + vbuf.append(v) + elif n == 2: + wbuf.append(v) + if not wbuf: + wbuf.append(None) + return [(v, w) for v in vbuf for w in wbuf] + valSerializer = PairSerializer(rdd.valSerializer, + OptionSerializer(other.valSerializer)) + return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + + +def python_cogroup(rdd, other, numSplits): + resultValSerializer = PairSerializer( + ArraySerializer(rdd.valSerializer), + ArraySerializer(other.valSerializer)) + vs = rdd.mapPairs(lambda (k, v): (k, (1, v))) + ws = other.mapPairs(lambda (k, v): (k, (2, v))) + def dispatch(seq): + vbuf, wbuf = [], [] + for (n, v) in seq: + if n == 1: + vbuf.append(v) + elif n == 2: + wbuf.append(v) + return (vbuf, wbuf) + return vs.union(ws).groupByKey(numSplits) \ + .mapValues(dispatch, resultValSerializer) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py new file mode 100644 index 0000000000..c892e86b93 --- /dev/null +++ b/pyspark/pyspark/rdd.py @@ -0,0 +1,517 @@ +from base64 import standard_b64encode as b64enc +from cloud.serialization import cloudpickle +from itertools import chain + +from pyspark.serializers import PairSerializer, NopSerializer, \ + OptionSerializer, ArraySerializer +from pyspark.join import python_join, python_left_outer_join, \ + python_right_outer_join, python_cogroup + + +class RDD(object): + + def __init__(self, jrdd, ctx, serializer=None): + self._jrdd = jrdd + self.is_cached = False + self.ctx = ctx + self.serializer = serializer or ctx.defaultSerializer + + def _builder(self, jrdd, ctx): + return RDD(jrdd, ctx, self.serializer) + + @property + def id(self): + return self._jrdd.id() + + @property + def splits(self): + return self._jrdd.splits() + + @classmethod + def _get_pipe_command(cls, command, functions): + if functions and not isinstance(functions, (list, tuple)): + functions = [functions] + worker_args = [command] + for f in functions: + worker_args.append(b64enc(cloudpickle.dumps(f))) + return " ".join(worker_args) + + def cache(self): + self.is_cached = True + self._jrdd.cache() + return self + + def map(self, f, serializer=None, preservesPartitioning=False): + return MappedRDD(self, f, serializer, preservesPartitioning) + + def mapPairs(self, f, keySerializer=None, valSerializer=None, + preservesPartitioning=False): + return PairMappedRDD(self, f, keySerializer, valSerializer, + preservesPartitioning) + + def flatMap(self, f, serializer=None): + """ + >>> rdd = sc.parallelize([2, 3, 4]) + >>> sorted(rdd.flatMap(lambda x: range(1, x)).collect()) + [1, 1, 1, 2, 2, 3] + """ + serializer = serializer or self.ctx.defaultSerializer + dumps = serializer.dumps + loads = self.serializer.loads + def func(x): + pickled_elems = (dumps(y) for y in f(loads(x))) + return "\n".join(pickled_elems) or None + pipe_command = RDD._get_pipe_command("map", [func]) + class_manifest = self._jrdd.classManifest() + jrdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, + False, self.ctx.pythonExec, + class_manifest).asJavaRDD() + return RDD(jrdd, self.ctx, serializer) + + def flatMapPairs(self, f, keySerializer=None, valSerializer=None, + preservesPartitioning=False): + """ + >>> rdd = sc.parallelize([2, 3, 4]) + >>> sorted(rdd.flatMapPairs(lambda x: [(x, x), (x, x)]).collect()) + [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] + """ + keySerializer = keySerializer or self.ctx.defaultSerializer + valSerializer = valSerializer or self.ctx.defaultSerializer + dumpk = keySerializer.dumps + dumpv = valSerializer.dumps + loads = self.serializer.loads + def func(x): + pairs = f(loads(x)) + pickled_pairs = ((dumpk(k), dumpv(v)) for (k, v) in pairs) + return "\n".join(chain.from_iterable(pickled_pairs)) or None + pipe_command = RDD._get_pipe_command("map", [func]) + class_manifest = self._jrdd.classManifest() + python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), pipe_command, + preservesPartitioning, self.ctx.pythonExec, class_manifest) + return PairRDD(python_rdd.asJavaPairRDD(), self.ctx, keySerializer, + valSerializer) + + def filter(self, f): + """ + >>> rdd = sc.parallelize([1, 2, 3, 4, 5]) + >>> rdd.filter(lambda x: x % 2 == 0).collect() + [2, 4] + """ + loads = self.serializer.loads + def filter_func(x): return x if f(loads(x)) else None + return self._builder(self._pipe(filter_func), self.ctx) + + def _pipe(self, functions, command="map"): + class_manifest = self._jrdd.classManifest() + pipe_command = RDD._get_pipe_command(command, functions) + python_rdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, + False, self.ctx.pythonExec, class_manifest) + return python_rdd.asJavaRDD() + + def _pipePairs(self, functions, command="mapPairs", + preservesPartitioning=False): + class_manifest = self._jrdd.classManifest() + pipe_command = RDD._get_pipe_command(command, functions) + python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), pipe_command, + preservesPartitioning, self.ctx.pythonExec, class_manifest) + return python_rdd.asJavaPairRDD() + + def distinct(self): + """ + >>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect()) + [1, 2, 3] + """ + if self.serializer.is_comparable: + return self._builder(self._jrdd.distinct(), self.ctx) + return self.mapPairs(lambda x: (x, "")) \ + .reduceByKey(lambda x, _: x) \ + .map(lambda (x, _): x) + + def sample(self, withReplacement, fraction, seed): + jrdd = self._jrdd.sample(withReplacement, fraction, seed) + return self._builder(jrdd, self.ctx) + + def takeSample(self, withReplacement, num, seed): + vals = self._jrdd.takeSample(withReplacement, num, seed) + return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + + def union(self, other): + """ + >>> rdd = sc.parallelize([1, 1, 2, 3]) + >>> rdd.union(rdd).collect() + [1, 1, 2, 3, 1, 1, 2, 3] + """ + return self._builder(self._jrdd.union(other._jrdd), self.ctx) + + # TODO: sort + + # TODO: Overload __add___? + + # TODO: glom + + def cartesian(self, other): + """ + >>> rdd = sc.parallelize([1, 2]) + >>> sorted(rdd.cartesian(rdd).collect()) + [(1, 1), (1, 2), (2, 1), (2, 2)] + """ + return PairRDD(self._jrdd.cartesian(other._jrdd), self.ctx) + + # numsplits + def groupBy(self, f, numSplits=None): + """ + >>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8]) + >>> sorted(rdd.groupBy(lambda x: x % 2).collect()) + [(0, [2, 8]), (1, [1, 1, 3, 5])] + """ + return self.mapPairs(lambda x: (f(x), x)).groupByKey(numSplits) + + # TODO: pipe + + # TODO: mapPartitions + + def foreach(self, f): + """ + >>> def f(x): print x + >>> sc.parallelize([1, 2, 3, 4, 5]).foreach(f) + """ + self.map(f).collect() # Force evaluation + + def collect(self): + vals = self._jrdd.collect() + return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + + def reduce(self, f, serializer=None): + """ + >>> import operator + >>> sc.parallelize([1, 2, 3, 4, 5]).reduce(operator.add) + 15 + """ + serializer = serializer or self.ctx.defaultSerializer + loads = self.serializer.loads + dumps = serializer.dumps + def reduceFunction(x, acc): + if acc is None: + return loads(x) + else: + return f(loads(x), acc) + vals = self._pipe([reduceFunction, dumps], command="reduce").collect() + return reduce(f, (serializer.loads(x) for x in vals)) + + # TODO: fold + + # TODO: aggregate + + def count(self): + """ + >>> sc.parallelize([2, 3, 4]).count() + 3L + """ + return self._jrdd.count() + + # TODO: count approx methods + + def take(self, num): + """ + >>> sc.parallelize([2, 3, 4]).take(2) + [2, 3] + """ + vals = self._jrdd.take(num) + return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + + def first(self): + """ + >>> sc.parallelize([2, 3, 4]).first() + 2 + """ + return self.serializer.loads(self.ctx.python_dump(self._jrdd.first())) + + # TODO: saveAsTextFile + + # TODO: saveAsObjectFile + + +class PairRDD(RDD): + + def __init__(self, jrdd, ctx, keySerializer=None, valSerializer=None): + RDD.__init__(self, jrdd, ctx) + self.keySerializer = keySerializer or ctx.defaultSerializer + self.valSerializer = valSerializer or ctx.defaultSerializer + self.serializer = \ + PairSerializer(self.keySerializer, self.valSerializer) + + def _builder(self, jrdd, ctx): + return PairRDD(jrdd, ctx, self.keySerializer, self.valSerializer) + + def reduceByKey(self, func, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> sorted(x.reduceByKey(lambda a, b: a + b).collect()) + [('a', 2), ('b', 1)] + """ + return self.combineByKey(lambda x: x, func, func, numSplits) + + # TODO: reduceByKeyLocally() + + # TODO: countByKey() + + # TODO: partitionBy + + def join(self, other, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) + >>> y = sc.parallelizePairs([("a", 2), ("a", 3)]) + >>> x.join(y).collect() + [('a', (1, 2)), ('a', (1, 3))] + + Check that we get a PairRDD-like object back: + >>> assert x.join(y).join + """ + assert self.keySerializer.name == other.keySerializer.name + if self.keySerializer.is_comparable: + return PairRDD(self._jrdd.join(other._jrdd), + self.ctx, self.keySerializer, + PairSerializer(self.valSerializer, other.valSerializer)) + else: + return python_join(self, other, numSplits) + + def leftOuterJoin(self, other, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) + >>> y = sc.parallelizePairs([("a", 2)]) + >>> sorted(x.leftOuterJoin(y).collect()) + [('a', (1, 2)), ('b', (4, None))] + """ + assert self.keySerializer.name == other.keySerializer.name + if self.keySerializer.is_comparable: + return PairRDD(self._jrdd.leftOuterJoin(other._jrdd), + self.ctx, self.keySerializer, + PairSerializer(self.valSerializer, + OptionSerializer(other.valSerializer))) + else: + return python_left_outer_join(self, other, numSplits) + + def rightOuterJoin(self, other, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) + >>> y = sc.parallelizePairs([("a", 2)]) + >>> sorted(y.rightOuterJoin(x).collect()) + [('a', (2, 1)), ('b', (None, 4))] + """ + assert self.keySerializer.name == other.keySerializer.name + if self.keySerializer.is_comparable: + return PairRDD(self._jrdd.rightOuterJoin(other._jrdd), + self.ctx, self.keySerializer, + PairSerializer(OptionSerializer(self.valSerializer), + other.valSerializer)) + else: + return python_right_outer_join(self, other, numSplits) + + def combineByKey(self, createCombiner, mergeValue, mergeCombiners, + numSplits=None, serializer=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> def f(x): return x + >>> def add(a, b): return a + str(b) + >>> sorted(x.combineByKey(str, add, add).collect()) + [('a', '11'), ('b', '1')] + """ + serializer = serializer or self.ctx.defaultSerializer + if numSplits is None: + numSplits = self.ctx.defaultParallelism + # Use hash() to create keys that are comparable in Java. + loadkv = self.serializer.loads + def pairify(kv): + # TODO: add method to deserialize only the key or value from + # a PairSerializer? + key = loadkv(kv)[0] + return (str(hash(key)), kv) + partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) + jrdd = self._pipePairs(pairify).partitionBy(partitioner) + pairified = PairRDD(jrdd, self.ctx, NopSerializer, self.serializer) + + loads = PairSerializer(NopSerializer, self.serializer).loads + dumpk = self.keySerializer.dumps + dumpc = serializer.dumps + + functions = [createCombiner, mergeValue, mergeCombiners, loads, dumpk, + dumpc] + jpairs = pairified._pipePairs(functions, "combine_by_key", + preservesPartitioning=True) + return PairRDD(jpairs, self.ctx, self.keySerializer, serializer) + + def groupByKey(self, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> sorted(x.groupByKey().collect()) + [('a', [1, 1]), ('b', [1])] + """ + + def createCombiner(x): + return [x] + + def mergeValue(xs, x): + xs.append(x) + return xs + + def mergeCombiners(a, b): + return a + b + + return self.combineByKey(createCombiner, mergeValue, mergeCombiners, + numSplits) + + def collectAsMap(self): + """ + >>> m = sc.parallelizePairs([(1, 2), (3, 4)]).collectAsMap() + >>> m[1] + 2 + >>> m[3] + 4 + """ + m = self._jrdd.collectAsMap() + def loads(x): + (k, v) = x + return (self.keySerializer.loads(k), self.valSerializer.loads(v)) + return dict(loads(x) for x in m.items()) + + def flatMapValues(self, f, valSerializer=None): + flat_map_fn = lambda (k, v): ((k, x) for x in f(v)) + return self.flatMapPairs(flat_map_fn, self.keySerializer, + valSerializer, True) + + def mapValues(self, f, valSerializer=None): + map_values_fn = lambda (k, v): (k, f(v)) + return self.mapPairs(map_values_fn, self.keySerializer, valSerializer, + True) + + # TODO: support varargs cogroup of several RDDs. + def groupWith(self, other): + return self.cogroup(other) + + def cogroup(self, other, numSplits=None): + """ + >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) + >>> y = sc.parallelizePairs([("a", 2)]) + >>> x.cogroup(y).collect() + [('a', ([1], [2])), ('b', ([4], []))] + """ + assert self.keySerializer.name == other.keySerializer.name + resultValSerializer = PairSerializer( + ArraySerializer(self.valSerializer), + ArraySerializer(other.valSerializer)) + if self.keySerializer.is_comparable: + return PairRDD(self._jrdd.cogroup(other._jrdd), + self.ctx, self.keySerializer, resultValSerializer) + else: + return python_cogroup(self, other, numSplits) + + # TODO: `lookup` is disabled because we can't make direct comparisons based + # on the key; we need to compare the hash of the key to the hash of the + # keys in the pairs. This could be an expensive operation, since those + # hashes aren't retained. + + # TODO: file saving + + +class MappedRDDBase(object): + def __init__(self, prev, func, serializer, preservesPartitioning=False): + if isinstance(prev, MappedRDDBase) and not prev.is_cached: + prev_func = prev.func + self.func = lambda x: func(prev_func(x)) + self.preservesPartitioning = \ + prev.preservesPartitioning and preservesPartitioning + self._prev_jrdd = prev._prev_jrdd + self._prev_serializer = prev._prev_serializer + else: + self.func = func + self.preservesPartitioning = preservesPartitioning + self._prev_jrdd = prev._jrdd + self._prev_serializer = prev.serializer + self.serializer = serializer or prev.ctx.defaultSerializer + self.is_cached = False + self.ctx = prev.ctx + self.prev = prev + self._jrdd_val = None + + +class MappedRDD(MappedRDDBase, RDD): + """ + >>> rdd = sc.parallelize([1, 2, 3, 4]) + >>> rdd.map(lambda x: 2 * x).cache().map(lambda x: 2 * x).collect() + [4, 8, 12, 16] + >>> rdd.map(lambda x: 2 * x).map(lambda x: 2 * x).collect() + [4, 8, 12, 16] + """ + + @property + def _jrdd(self): + if not self._jrdd_val: + udf = self.func + loads = self._prev_serializer.loads + dumps = self.serializer.dumps + func = lambda x: dumps(udf(loads(x))) + pipe_command = RDD._get_pipe_command("map", [func]) + class_manifest = self._prev_jrdd.classManifest() + python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), + pipe_command, self.preservesPartitioning, self.ctx.pythonExec, + class_manifest) + self._jrdd_val = python_rdd.asJavaRDD() + return self._jrdd_val + + +class PairMappedRDD(MappedRDDBase, PairRDD): + """ + >>> rdd = sc.parallelize([1, 2, 3, 4]) + >>> rdd.mapPairs(lambda x: (x, x)) \\ + ... .mapPairs(lambda (x, y): (2*x, 2*y)) \\ + ... .collect() + [(2, 2), (4, 4), (6, 6), (8, 8)] + >>> rdd.mapPairs(lambda x: (x, x)) \\ + ... .mapPairs(lambda (x, y): (2*x, 2*y)) \\ + ... .map(lambda (x, _): x).collect() + [2, 4, 6, 8] + """ + + def __init__(self, prev, func, keySerializer=None, valSerializer=None, + preservesPartitioning=False): + self.keySerializer = keySerializer or prev.ctx.defaultSerializer + self.valSerializer = valSerializer or prev.ctx.defaultSerializer + serializer = PairSerializer(self.keySerializer, self.valSerializer) + MappedRDDBase.__init__(self, prev, func, serializer, + preservesPartitioning) + + @property + def _jrdd(self): + if not self._jrdd_val: + udf = self.func + loads = self._prev_serializer.loads + dumpk = self.keySerializer.dumps + dumpv = self.valSerializer.dumps + def func(x): + (k, v) = udf(loads(x)) + return (dumpk(k), dumpv(v)) + pipe_command = RDD._get_pipe_command("mapPairs", [func]) + class_manifest = self._prev_jrdd.classManifest() + self._jrdd_val = self.ctx.jvm.PythonPairRDD(self._prev_jrdd.rdd(), + pipe_command, self.preservesPartitioning, self.ctx.pythonExec, + class_manifest).asJavaPairRDD() + return self._jrdd_val + + +def _test(): + import doctest + from pyspark.context import SparkContext + from pyspark.serializers import PickleSerializer, JSONSerializer + globs = globals().copy() + globs['sc'] = SparkContext('local', 'PythonTest', + defaultSerializer=JSONSerializer) + doctest.testmod(globs=globs) + globs['sc'].stop() + globs['sc'] = SparkContext('local', 'PythonTest', + defaultSerializer=PickleSerializer) + doctest.testmod(globs=globs) + globs['sc'].stop() + + +if __name__ == "__main__": + _test() diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py new file mode 100644 index 0000000000..b113f5656b --- /dev/null +++ b/pyspark/pyspark/serializers.py @@ -0,0 +1,229 @@ +""" +Data serialization methods. + +The Spark Python API is built on top of the Spark Java API. RDDs created in +Python are stored in Java as RDDs of Strings. Python objects are automatically +serialized/deserialized, so this representation is transparent to the end-user. + +------------------ +Serializer objects +------------------ + +`Serializer` objects are used to customize how an RDD's values are serialized. + +Each `Serializer` is a named tuple with four fields: + + - A `dumps` function, for serializing a Python object to a string. + + - A `loads` function, for deserializing a Python object from a string. + + - An `is_comparable` field, True if equal Python objects are serialized to + equal strings, and False otherwise. + + - A `name` field, used to identify the Serializer. Serializers are + compared for equality by comparing their names. + +The serializer's output should be base64-encoded. + +------------------------------------------------------------------ +`is_comparable`: comparing serialized representations for equality +------------------------------------------------------------------ + +If `is_comparable` is False, the serializer's representations of equal objects +are not required to be equal: + +>>> import pickle +>>> a = {1: 0, 9: 0} +>>> b = {9: 0, 1: 0} +>>> a == b +True +>>> pickle.dumps(a) == pickle.dumps(b) +False + +RDDs with comparable serializers can use native Java implementations of +operations like join() and distinct(), which may lead to better performance by +eliminating deserialization and Python comparisons. + +The default JSONSerializer produces comparable representations of common Python +data structures. + +-------------------------------------- +Examples of serialized representations +-------------------------------------- + +The RDD transformations that use Python UDFs are implemented in terms of +a modified `PipedRDD.pipe()` function. For each record `x` in the RDD, the +`pipe()` function pipes `x.toString()` to a Python worker process, which +deserializes the string into a Python object, executes user-defined functions, +and outputs serialized Python objects. + +The regular `toString()` method returns an ambiguous representation, due to the +way that Scala `Option` instances are printed: + +>>> from context import SparkContext +>>> sc = SparkContext("local", "SerializerDocs") +>>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) +>>> y = sc.parallelizePairs([("a", 2)]) + +>>> print y.rightOuterJoin(x)._jrdd.first().toString() +(ImEi,(Some(Mg==),MQ==)) + +In Java, preprocessing is performed to handle Option instances, so the Python +process receives unambiguous input: + +>>> print sc.python_dump(y.rightOuterJoin(x)._jrdd.first()) +(ImEi,(Mg==,MQ==)) + +The base64-encoding eliminates the need to escape newlines, parentheses and +other special characters. + +---------------------- +Serializer composition +---------------------- + +In order to handle nested structures, which could contain object serialized +with different serializers, the RDD module composes serializers. For example, +the serializers in the previous example are: + +>>> print x.serializer.name +PairSerializer + +>>> print y.serializer.name +PairSerializer + +>>> print y.rightOuterJoin(x).serializer.name +PairSerializer, JSONSerializer>> +""" +from base64 import standard_b64encode, standard_b64decode +from collections import namedtuple +import cPickle +import simplejson + + +Serializer = namedtuple("Serializer", + ["dumps","loads", "is_comparable", "name"]) + + +NopSerializer = Serializer(str, str, True, "NopSerializer") + + +JSONSerializer = Serializer( + lambda obj: standard_b64encode(simplejson.dumps(obj, sort_keys=True, + separators=(',', ':'))), + lambda s: simplejson.loads(standard_b64decode(s)), + True, + "JSONSerializer" +) + + +PickleSerializer = Serializer( + lambda obj: standard_b64encode(cPickle.dumps(obj)), + lambda s: cPickle.loads(standard_b64decode(s)), + False, + "PickleSerializer" +) + + +def OptionSerializer(serializer): + """ + >>> ser = OptionSerializer(NopSerializer) + >>> ser.loads(ser.dumps("Hello, World!")) + 'Hello, World!' + >>> ser.loads(ser.dumps(None)) is None + True + """ + none_placeholder = '*' + + def dumps(x): + if x is None: + return none_placeholder + else: + return serializer.dumps(x) + + def loads(x): + if x == none_placeholder: + return None + else: + return serializer.loads(x) + + name = "OptionSerializer<%s>" % serializer.name + return Serializer(dumps, loads, serializer.is_comparable, name) + + +def PairSerializer(keySerializer, valSerializer): + """ + Returns a Serializer for a (key, value) pair. + + >>> ser = PairSerializer(JSONSerializer, JSONSerializer) + >>> ser.loads(ser.dumps((1, 2))) + (1, 2) + + >>> ser = PairSerializer(JSONSerializer, ser) + >>> ser.loads(ser.dumps((1, (2, 3)))) + (1, (2, 3)) + """ + def loads(kv): + try: + (key, val) = kv[1:-1].split(',', 1) + key = keySerializer.loads(key) + val = valSerializer.loads(val) + return (key, val) + except: + print "Error in deserializing pair from '%s'" % str(kv) + raise + + def dumps(kv): + (key, val) = kv + return"(%s,%s)" % (keySerializer.dumps(key), valSerializer.dumps(val)) + is_comparable = \ + keySerializer.is_comparable and valSerializer.is_comparable + name = "PairSerializer<%s, %s>" % (keySerializer.name, valSerializer.name) + return Serializer(dumps, loads, is_comparable, name) + + +def ArraySerializer(serializer): + """ + >>> ser = ArraySerializer(JSONSerializer) + >>> ser.loads(ser.dumps([1, 2, 3, 4])) + [1, 2, 3, 4] + >>> ser = ArraySerializer(PairSerializer(JSONSerializer, PickleSerializer)) + >>> ser.loads(ser.dumps([('a', 1), ('b', 2)])) + [('a', 1), ('b', 2)] + >>> ser.loads(ser.dumps([('a', 1)])) + [('a', 1)] + >>> ser.loads(ser.dumps([])) + [] + """ + def dumps(arr): + if arr == []: + return '[]' + else: + return '[' + '|'.join(serializer.dumps(x) for x in arr) + ']' + + def loads(s): + if s == '[]': + return [] + items = s[1:-1] + if '|' in items: + items = items.split('|') + else: + items = [items] + return [serializer.loads(x) for x in items] + + name = "ArraySerializer<%s>" % serializer.name + return Serializer(dumps, loads, serializer.is_comparable, name) + + +# TODO: IntegerSerializer + + +# TODO: DoubleSerializer + + +def _test(): + import doctest + doctest.testmod() + + +if __name__ == "__main__": + _test() diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py new file mode 100644 index 0000000000..4d4cc939c3 --- /dev/null +++ b/pyspark/pyspark/worker.py @@ -0,0 +1,97 @@ +""" +Worker that receives input from Piped RDD. +""" +import sys +from base64 import standard_b64decode +# CloudPickler needs to be imported so that depicklers are registered using the +# copy_reg module. +from cloud.serialization.cloudpickle import CloudPickler +import cPickle + + +# Redirect stdout to stderr so that users must return values from functions. +old_stdout = sys.stdout +sys.stdout = sys.stderr + + +def load_function(): + return cPickle.loads(standard_b64decode(sys.stdin.readline().strip())) + + +def output(x): + for line in x.split("\n"): + old_stdout.write(line.rstrip("\r\n") + "\n") + + +def read_input(): + for line in sys.stdin: + yield line.rstrip("\r\n") + + +def do_combine_by_key(): + create_combiner = load_function() + merge_value = load_function() + merge_combiners = load_function() # TODO: not used. + depickler = load_function() + key_pickler = load_function() + combiner_pickler = load_function() + combiners = {} + for line in read_input(): + # Discard the hashcode added in the Python combineByKey() method. + (key, value) = depickler(line)[1] + if key not in combiners: + combiners[key] = create_combiner(value) + else: + combiners[key] = merge_value(combiners[key], value) + for (key, combiner) in combiners.iteritems(): + output(key_pickler(key)) + output(combiner_pickler(combiner)) + + +def do_map(map_pairs=False): + f = load_function() + for line in read_input(): + try: + out = f(line) + if out is not None: + if map_pairs: + for x in out: + output(x) + else: + output(out) + except: + sys.stderr.write("Error processing line '%s'\n" % line) + raise + + +def do_reduce(): + f = load_function() + dumps = load_function() + acc = None + for line in read_input(): + acc = f(line, acc) + output(dumps(acc)) + + +def do_echo(): + old_stdout.writelines(sys.stdin.readlines()) + + +def main(): + command = sys.stdin.readline().strip() + if command == "map": + do_map(map_pairs=False) + elif command == "mapPairs": + do_map(map_pairs=True) + elif command == "combine_by_key": + do_combine_by_key() + elif command == "reduce": + do_reduce() + elif command == "echo": + do_echo() + else: + raise Exception("Unsupported command %s" % command) + + +if __name__ == '__main__': + main() diff --git a/pyspark/requirements.txt b/pyspark/requirements.txt new file mode 100644 index 0000000000..d9b3fe40bd --- /dev/null +++ b/pyspark/requirements.txt @@ -0,0 +1,9 @@ +# The Python API relies on some new features from the Py4J development branch. +# pip can't install Py4J from git because the setup.py file for the Python +# package is not at the root of the git repository. It may be possible to +# install Py4J from git once https://github.com/pypa/pip/pull/526 is merged. + +# git+git://github.com/bartdag/py4j.git@3dbf380d3d2cdeb9aab394454ea74d80c4aba1ea + +simplejson==2.6.1 +cloud==2.5.5 diff --git a/python/tc.py b/python/tc.py new file mode 100644 index 0000000000..5dcc4317e0 --- /dev/null +++ b/python/tc.py @@ -0,0 +1,22 @@ +from rdd import SparkContext + +sc = SparkContext("local", "PythonWordCount") +e = [(1, 2), (2, 3), (4, 1)] + +tc = sc.parallelizePairs(e) + +edges = tc.mapPairs(lambda (x, y): (y, x)) + +oldCount = 0 +nextCount = tc.count() + +def project(x): + return (x[1][1], x[1][0]) + +while nextCount != oldCount: + oldCount = nextCount + tc = tc.union(tc.join(edges).mapPairs(project)).distinct() + nextCount = tc.count() + +print "TC has %i edges" % tc.count() +print tc.collect() From 13b9514966a423f80f672f23f42ec3f0113936fd Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sun, 19 Aug 2012 17:12:51 -0700 Subject: [PATCH 02/85] Bundle cloudpickle with pyspark. --- pyspark/pyspark/cloudpickle.py | 974 +++++++++++++++++++++++++++++++++ pyspark/pyspark/rdd.py | 2 +- pyspark/pyspark/worker.py | 2 +- pyspark/requirements.txt | 3 - 4 files changed, 976 insertions(+), 5 deletions(-) create mode 100644 pyspark/pyspark/cloudpickle.py diff --git a/pyspark/pyspark/cloudpickle.py b/pyspark/pyspark/cloudpickle.py new file mode 100644 index 0000000000..6a7c23a069 --- /dev/null +++ b/pyspark/pyspark/cloudpickle.py @@ -0,0 +1,974 @@ +""" +This class is defined to override standard pickle functionality + +The goals of it follow: +-Serialize lambdas and nested functions to compiled byte code +-Deal with main module correctly +-Deal with other non-serializable objects + +It does not include an unpickler, as standard python unpickling suffices. + +This module was extracted from the `cloud` package, developed by `PiCloud, Inc. +`_. + +Copyright (c) 2012, Regents of the University of California. +Copyright (c) 2009 `PiCloud, Inc. `_. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the University of California, Berkeley nor the + names of its contributors may be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" + + +import operator +import os +import pickle +import struct +import sys +import types +from functools import partial +import itertools +from copy_reg import _extension_registry, _inverted_registry, _extension_cache +import new +import dis +import traceback + +#relevant opcodes +STORE_GLOBAL = chr(dis.opname.index('STORE_GLOBAL')) +DELETE_GLOBAL = chr(dis.opname.index('DELETE_GLOBAL')) +LOAD_GLOBAL = chr(dis.opname.index('LOAD_GLOBAL')) +GLOBAL_OPS = [STORE_GLOBAL, DELETE_GLOBAL, LOAD_GLOBAL] + +HAVE_ARGUMENT = chr(dis.HAVE_ARGUMENT) +EXTENDED_ARG = chr(dis.EXTENDED_ARG) + +import logging +cloudLog = logging.getLogger("Cloud.Transport") + +try: + import ctypes +except (MemoryError, ImportError): + logging.warning('Exception raised on importing ctypes. Likely python bug.. some functionality will be disabled', exc_info = True) + ctypes = None + PyObject_HEAD = None +else: + + # for reading internal structures + PyObject_HEAD = [ + ('ob_refcnt', ctypes.c_size_t), + ('ob_type', ctypes.c_void_p), + ] + + +try: + from cStringIO import StringIO +except ImportError: + from StringIO import StringIO + +# These helper functions were copied from PiCloud's util module. +def islambda(func): + return getattr(func,'func_name') == '' + +def xrange_params(xrangeobj): + """Returns a 3 element tuple describing the xrange start, step, and len + respectively + + Note: Only guarentees that elements of xrange are the same. parameters may + be different. + e.g. xrange(1,1) is interpretted as xrange(0,0); both behave the same + though w/ iteration + """ + + xrange_len = len(xrangeobj) + if not xrange_len: #empty + return (0,1,0) + start = xrangeobj[0] + if xrange_len == 1: #one element + return start, 1, 1 + return (start, xrangeobj[1] - xrangeobj[0], xrange_len) + +#debug variables intended for developer use: +printSerialization = False +printMemoization = False + +useForcedImports = True #Should I use forced imports for tracking? + + + +class CloudPickler(pickle.Pickler): + + dispatch = pickle.Pickler.dispatch.copy() + savedForceImports = False + savedDjangoEnv = False #hack tro transport django environment + + def __init__(self, file, protocol=None, min_size_to_save= 0): + pickle.Pickler.__init__(self,file,protocol) + self.modules = set() #set of modules needed to depickle + self.globals_ref = {} # map ids to dictionary. used to ensure that functions can share global env + + def dump(self, obj): + # note: not thread safe + # minimal side-effects, so not fixing + recurse_limit = 3000 + base_recurse = sys.getrecursionlimit() + if base_recurse < recurse_limit: + sys.setrecursionlimit(recurse_limit) + self.inject_addons() + try: + return pickle.Pickler.dump(self, obj) + except RuntimeError, e: + if 'recursion' in e.args[0]: + msg = """Could not pickle object as excessively deep recursion required. + Try _fast_serialization=2 or contact PiCloud support""" + raise pickle.PicklingError(msg) + finally: + new_recurse = sys.getrecursionlimit() + if new_recurse == recurse_limit: + sys.setrecursionlimit(base_recurse) + + def save_buffer(self, obj): + """Fallback to save_string""" + pickle.Pickler.save_string(self,str(obj)) + dispatch[buffer] = save_buffer + + #block broken objects + def save_unsupported(self, obj, pack=None): + raise pickle.PicklingError("Cannot pickle objects of type %s" % type(obj)) + dispatch[types.GeneratorType] = save_unsupported + + #python2.6+ supports slice pickling. some py2.5 extensions might as well. We just test it + try: + slice(0,1).__reduce__() + except TypeError: #can't pickle - + dispatch[slice] = save_unsupported + + #itertools objects do not pickle! + for v in itertools.__dict__.values(): + if type(v) is type: + dispatch[v] = save_unsupported + + + def save_dict(self, obj): + """hack fix + If the dict is a global, deal with it in a special way + """ + #print 'saving', obj + if obj is __builtins__: + self.save_reduce(_get_module_builtins, (), obj=obj) + else: + pickle.Pickler.save_dict(self, obj) + dispatch[pickle.DictionaryType] = save_dict + + + def save_module(self, obj, pack=struct.pack): + """ + Save a module as an import + """ + #print 'try save import', obj.__name__ + self.modules.add(obj) + self.save_reduce(subimport,(obj.__name__,), obj=obj) + dispatch[types.ModuleType] = save_module #new type + + def save_codeobject(self, obj, pack=struct.pack): + """ + Save a code object + """ + #print 'try to save codeobj: ', obj + args = ( + obj.co_argcount, obj.co_nlocals, obj.co_stacksize, obj.co_flags, obj.co_code, + obj.co_consts, obj.co_names, obj.co_varnames, obj.co_filename, obj.co_name, + obj.co_firstlineno, obj.co_lnotab, obj.co_freevars, obj.co_cellvars + ) + self.save_reduce(types.CodeType, args, obj=obj) + dispatch[types.CodeType] = save_codeobject #new type + + def save_function(self, obj, name=None, pack=struct.pack): + """ Registered with the dispatch to handle all function types. + + Determines what kind of function obj is (e.g. lambda, defined at + interactive prompt, etc) and handles the pickling appropriately. + """ + write = self.write + + name = obj.__name__ + modname = pickle.whichmodule(obj, name) + #print 'which gives %s %s %s' % (modname, obj, name) + try: + themodule = sys.modules[modname] + except KeyError: # eval'd items such as namedtuple give invalid items for their function __module__ + modname = '__main__' + + if modname == '__main__': + themodule = None + + if themodule: + self.modules.add(themodule) + + if not self.savedDjangoEnv: + #hack for django - if we detect the settings module, we transport it + django_settings = os.environ.get('DJANGO_SETTINGS_MODULE', '') + if django_settings: + django_mod = sys.modules.get(django_settings) + if django_mod: + cloudLog.debug('Transporting django settings %s during save of %s', django_mod, name) + self.savedDjangoEnv = True + self.modules.add(django_mod) + write(pickle.MARK) + self.save_reduce(django_settings_load, (django_mod.__name__,), obj=django_mod) + write(pickle.POP_MARK) + + + # if func is lambda, def'ed at prompt, is in main, or is nested, then + # we'll pickle the actual function object rather than simply saving a + # reference (as is done in default pickler), via save_function_tuple. + if islambda(obj) or obj.func_code.co_filename == '' or themodule == None: + #Force server to import modules that have been imported in main + modList = None + if themodule == None and not self.savedForceImports: + mainmod = sys.modules['__main__'] + if useForcedImports and hasattr(mainmod,'___pyc_forcedImports__'): + modList = list(mainmod.___pyc_forcedImports__) + self.savedForceImports = True + self.save_function_tuple(obj, modList) + return + else: # func is nested + klass = getattr(themodule, name, None) + if klass is None or klass is not obj: + self.save_function_tuple(obj, [themodule]) + return + + if obj.__dict__: + # essentially save_reduce, but workaround needed to avoid recursion + self.save(_restore_attr) + write(pickle.MARK + pickle.GLOBAL + modname + '\n' + name + '\n') + self.memoize(obj) + self.save(obj.__dict__) + write(pickle.TUPLE + pickle.REDUCE) + else: + write(pickle.GLOBAL + modname + '\n' + name + '\n') + self.memoize(obj) + dispatch[types.FunctionType] = save_function + + def save_function_tuple(self, func, forced_imports): + """ Pickles an actual func object. + + A func comprises: code, globals, defaults, closure, and dict. We + extract and save these, injecting reducing functions at certain points + to recreate the func object. Keep in mind that some of these pieces + can contain a ref to the func itself. Thus, a naive save on these + pieces could trigger an infinite loop of save's. To get around that, + we first create a skeleton func object using just the code (this is + safe, since this won't contain a ref to the func), and memoize it as + soon as it's created. The other stuff can then be filled in later. + """ + save = self.save + write = self.write + + # save the modules (if any) + if forced_imports: + write(pickle.MARK) + save(_modules_to_main) + #print 'forced imports are', forced_imports + + forced_names = map(lambda m: m.__name__, forced_imports) + save((forced_names,)) + + #save((forced_imports,)) + write(pickle.REDUCE) + write(pickle.POP_MARK) + + code, f_globals, defaults, closure, dct, base_globals = self.extract_func_data(func) + + save(_fill_function) # skeleton function updater + write(pickle.MARK) # beginning of tuple that _fill_function expects + + # create a skeleton function object and memoize it + save(_make_skel_func) + save((code, len(closure), base_globals)) + write(pickle.REDUCE) + self.memoize(func) + + # save the rest of the func data needed by _fill_function + save(f_globals) + save(defaults) + save(closure) + save(dct) + write(pickle.TUPLE) + write(pickle.REDUCE) # applies _fill_function on the tuple + + @staticmethod + def extract_code_globals(co): + """ + Find all globals names read or written to by codeblock co + """ + code = co.co_code + names = co.co_names + out_names = set() + + n = len(code) + i = 0 + extended_arg = 0 + while i < n: + op = code[i] + + i = i+1 + if op >= HAVE_ARGUMENT: + oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg + extended_arg = 0 + i = i+2 + if op == EXTENDED_ARG: + extended_arg = oparg*65536L + if op in GLOBAL_OPS: + out_names.add(names[oparg]) + #print 'extracted', out_names, ' from ', names + return out_names + + def extract_func_data(self, func): + """ + Turn the function into a tuple of data necessary to recreate it: + code, globals, defaults, closure, dict + """ + code = func.func_code + + # extract all global ref's + func_global_refs = CloudPickler.extract_code_globals(code) + if code.co_consts: # see if nested function have any global refs + for const in code.co_consts: + if type(const) is types.CodeType and const.co_names: + func_global_refs = func_global_refs.union( CloudPickler.extract_code_globals(const)) + # process all variables referenced by global environment + f_globals = {} + for var in func_global_refs: + #Some names, such as class functions are not global - we don't need them + if func.func_globals.has_key(var): + f_globals[var] = func.func_globals[var] + + # defaults requires no processing + defaults = func.func_defaults + + def get_contents(cell): + try: + return cell.cell_contents + except ValueError, e: #cell is empty error on not yet assigned + raise pickle.PicklingError('Function to be pickled has free variables that are referenced before assignment in enclosing scope') + + + # process closure + if func.func_closure: + closure = map(get_contents, func.func_closure) + else: + closure = [] + + # save the dict + dct = func.func_dict + + if printSerialization: + outvars = ['code: ' + str(code) ] + outvars.append('globals: ' + str(f_globals)) + outvars.append('defaults: ' + str(defaults)) + outvars.append('closure: ' + str(closure)) + print 'function ', func, 'is extracted to: ', ', '.join(outvars) + + base_globals = self.globals_ref.get(id(func.func_globals), {}) + self.globals_ref[id(func.func_globals)] = base_globals + + return (code, f_globals, defaults, closure, dct, base_globals) + + def save_global(self, obj, name=None, pack=struct.pack): + write = self.write + memo = self.memo + + if name is None: + name = obj.__name__ + + modname = getattr(obj, "__module__", None) + if modname is None: + modname = pickle.whichmodule(obj, name) + + try: + __import__(modname) + themodule = sys.modules[modname] + except (ImportError, KeyError, AttributeError): #should never occur + raise pickle.PicklingError( + "Can't pickle %r: Module %s cannot be found" % + (obj, modname)) + + if modname == '__main__': + themodule = None + + if themodule: + self.modules.add(themodule) + + sendRef = True + typ = type(obj) + #print 'saving', obj, typ + try: + try: #Deal with case when getattribute fails with exceptions + klass = getattr(themodule, name) + except (AttributeError): + if modname == '__builtin__': #new.* are misrepeported + modname = 'new' + __import__(modname) + themodule = sys.modules[modname] + try: + klass = getattr(themodule, name) + except AttributeError, a: + #print themodule, name, obj, type(obj) + raise pickle.PicklingError("Can't pickle builtin %s" % obj) + else: + raise + + except (ImportError, KeyError, AttributeError): + if typ == types.TypeType or typ == types.ClassType: + sendRef = False + else: #we can't deal with this + raise + else: + if klass is not obj and (typ == types.TypeType or typ == types.ClassType): + sendRef = False + if not sendRef: + #note: Third party types might crash this - add better checks! + d = dict(obj.__dict__) #copy dict proxy to a dict + if not isinstance(d.get('__dict__', None), property): # don't extract dict that are properties + d.pop('__dict__',None) + d.pop('__weakref__',None) + + # hack as __new__ is stored differently in the __dict__ + new_override = d.get('__new__', None) + if new_override: + d['__new__'] = obj.__new__ + + self.save_reduce(type(obj),(obj.__name__,obj.__bases__, + d),obj=obj) + #print 'internal reduce dask %s %s' % (obj, d) + return + + if self.proto >= 2: + code = _extension_registry.get((modname, name)) + if code: + assert code > 0 + if code <= 0xff: + write(pickle.EXT1 + chr(code)) + elif code <= 0xffff: + write("%c%c%c" % (pickle.EXT2, code&0xff, code>>8)) + else: + write(pickle.EXT4 + pack("= 2 and getattr(func, "__name__", "") == "__newobj__": + #Added fix to allow transient + cls = args[0] + if not hasattr(cls, "__new__"): + raise pickle.PicklingError( + "args[0] from __newobj__ args has no __new__") + if obj is not None and cls is not obj.__class__: + raise pickle.PicklingError( + "args[0] from __newobj__ args has the wrong class") + args = args[1:] + save(cls) + + #Don't pickle transient entries + if hasattr(obj, '__transient__'): + transient = obj.__transient__ + state = state.copy() + + for k in list(state.keys()): + if k in transient: + del state[k] + + save(args) + write(pickle.NEWOBJ) + else: + save(func) + save(args) + write(pickle.REDUCE) + + if obj is not None: + self.memoize(obj) + + # More new special cases (that work with older protocols as + # well): when __reduce__ returns a tuple with 4 or 5 items, + # the 4th and 5th item should be iterators that provide list + # items and dict items (as (key, value) tuples), or None. + + if listitems is not None: + self._batch_appends(listitems) + + if dictitems is not None: + self._batch_setitems(dictitems) + + if state is not None: + #print 'obj %s has state %s' % (obj, state) + save(state) + write(pickle.BUILD) + + + def save_xrange(self, obj): + """Save an xrange object in python 2.5 + Python 2.6 supports this natively + """ + range_params = xrange_params(obj) + self.save_reduce(_build_xrange,range_params) + + #python2.6+ supports xrange pickling. some py2.5 extensions might as well. We just test it + try: + xrange(0).__reduce__() + except TypeError: #can't pickle -- use PiCloud pickler + dispatch[xrange] = save_xrange + + def save_partial(self, obj): + """Partial objects do not serialize correctly in python2.x -- this fixes the bugs""" + self.save_reduce(_genpartial, (obj.func, obj.args, obj.keywords)) + + if sys.version_info < (2,7): #2.7 supports partial pickling + dispatch[partial] = save_partial + + + def save_file(self, obj): + """Save a file""" + import StringIO as pystringIO #we can't use cStringIO as it lacks the name attribute + from ..transport.adapter import SerializingAdapter + + if not hasattr(obj, 'name') or not hasattr(obj, 'mode'): + raise pickle.PicklingError("Cannot pickle files that do not map to an actual file") + if obj.name == '': + return self.save_reduce(getattr, (sys,'stdout'), obj=obj) + if obj.name == '': + return self.save_reduce(getattr, (sys,'stderr'), obj=obj) + if obj.name == '': + raise pickle.PicklingError("Cannot pickle standard input") + if hasattr(obj, 'isatty') and obj.isatty(): + raise pickle.PicklingError("Cannot pickle files that map to tty objects") + if 'r' not in obj.mode: + raise pickle.PicklingError("Cannot pickle files that are not opened for reading") + name = obj.name + try: + fsize = os.stat(name).st_size + except OSError: + raise pickle.PicklingError("Cannot pickle file %s as it cannot be stat" % name) + + if obj.closed: + #create an empty closed string io + retval = pystringIO.StringIO("") + retval.close() + elif not fsize: #empty file + retval = pystringIO.StringIO("") + try: + tmpfile = file(name) + tst = tmpfile.read(1) + except IOError: + raise pickle.PicklingError("Cannot pickle file %s as it cannot be read" % name) + tmpfile.close() + if tst != '': + raise pickle.PicklingError("Cannot pickle file %s as it does not appear to map to a physical, real file" % name) + elif fsize > SerializingAdapter.max_transmit_data: + raise pickle.PicklingError("Cannot pickle file %s as it exceeds cloudconf.py's max_transmit_data of %d" % + (name,SerializingAdapter.max_transmit_data)) + else: + try: + tmpfile = file(name) + contents = tmpfile.read(SerializingAdapter.max_transmit_data) + tmpfile.close() + except IOError: + raise pickle.PicklingError("Cannot pickle file %s as it cannot be read" % name) + retval = pystringIO.StringIO(contents) + curloc = obj.tell() + retval.seek(curloc) + + retval.name = name + self.save(retval) #save stringIO + self.memoize(obj) + + dispatch[file] = save_file + """Special functions for Add-on libraries""" + + def inject_numpy(self): + numpy = sys.modules.get('numpy') + if not numpy or not hasattr(numpy, 'ufunc'): + return + self.dispatch[numpy.ufunc] = self.__class__.save_ufunc + + numpy_tst_mods = ['numpy', 'scipy.special'] + def save_ufunc(self, obj): + """Hack function for saving numpy ufunc objects""" + name = obj.__name__ + for tst_mod_name in self.numpy_tst_mods: + tst_mod = sys.modules.get(tst_mod_name, None) + if tst_mod: + if name in tst_mod.__dict__: + self.save_reduce(_getobject, (tst_mod_name, name)) + return + raise pickle.PicklingError('cannot save %s. Cannot resolve what module it is defined in' % str(obj)) + + def inject_timeseries(self): + """Handle bugs with pickling scikits timeseries""" + tseries = sys.modules.get('scikits.timeseries.tseries') + if not tseries or not hasattr(tseries, 'Timeseries'): + return + self.dispatch[tseries.Timeseries] = self.__class__.save_timeseries + + def save_timeseries(self, obj): + import scikits.timeseries.tseries as ts + + func, reduce_args, state = obj.__reduce__() + if func != ts._tsreconstruct: + raise pickle.PicklingError('timeseries using unexpected reconstruction function %s' % str(func)) + state = (1, + obj.shape, + obj.dtype, + obj.flags.fnc, + obj._data.tostring(), + ts.getmaskarray(obj).tostring(), + obj._fill_value, + obj._dates.shape, + obj._dates.__array__().tostring(), + obj._dates.dtype, #added -- preserve type + obj.freq, + obj._optinfo, + ) + return self.save_reduce(_genTimeSeries, (reduce_args, state)) + + def inject_email(self): + """Block email LazyImporters from being saved""" + email = sys.modules.get('email') + if not email: + return + self.dispatch[email.LazyImporter] = self.__class__.save_unsupported + + def inject_addons(self): + """Plug in system. Register additional pickling functions if modules already loaded""" + self.inject_numpy() + self.inject_timeseries() + self.inject_email() + + """Python Imaging Library""" + def save_image(self, obj): + if not obj.im and obj.fp and 'r' in obj.fp.mode and obj.fp.name \ + and not obj.fp.closed and (not hasattr(obj, 'isatty') or not obj.isatty()): + #if image not loaded yet -- lazy load + self.save_reduce(_lazyloadImage,(obj.fp,), obj=obj) + else: + #image is loaded - just transmit it over + self.save_reduce(_generateImage, (obj.size, obj.mode, obj.tostring()), obj=obj) + + """ + def memoize(self, obj): + pickle.Pickler.memoize(self, obj) + if printMemoization: + print 'memoizing ' + str(obj) + """ + + + +# Shorthands for legacy support + +def dump(obj, file, protocol=2): + CloudPickler(file, protocol).dump(obj) + +def dumps(obj, protocol=2): + file = StringIO() + + cp = CloudPickler(file,protocol) + cp.dump(obj) + + #print 'cloud dumped', str(obj), str(cp.modules) + + return file.getvalue() + + +#hack for __import__ not working as desired +def subimport(name): + __import__(name) + return sys.modules[name] + +#hack to load django settings: +def django_settings_load(name): + modified_env = False + + if 'DJANGO_SETTINGS_MODULE' not in os.environ: + os.environ['DJANGO_SETTINGS_MODULE'] = name # must set name first due to circular deps + modified_env = True + try: + module = subimport(name) + except Exception, i: + print >> sys.stderr, 'Cloud not import django settings %s:' % (name) + print_exec(sys.stderr) + if modified_env: + del os.environ['DJANGO_SETTINGS_MODULE'] + else: + #add project directory to sys,path: + if hasattr(module,'__file__'): + dirname = os.path.split(module.__file__)[0] + '/' + sys.path.append(dirname) + +# restores function attributes +def _restore_attr(obj, attr): + for key, val in attr.items(): + setattr(obj, key, val) + return obj + +def _get_module_builtins(): + return pickle.__builtins__ + +def print_exec(stream): + ei = sys.exc_info() + traceback.print_exception(ei[0], ei[1], ei[2], None, stream) + +def _modules_to_main(modList): + """Force every module in modList to be placed into main""" + if not modList: + return + + main = sys.modules['__main__'] + for modname in modList: + if type(modname) is str: + try: + mod = __import__(modname) + except Exception, i: #catch all... + sys.stderr.write('warning: could not import %s\n. Your function may unexpectedly error due to this import failing; \ +A version mismatch is likely. Specific error was:\n' % modname) + print_exec(sys.stderr) + else: + setattr(main,mod.__name__, mod) + else: + #REVERSE COMPATIBILITY FOR CLOUD CLIENT 1.5 (WITH EPD) + #In old version actual module was sent + setattr(main,modname.__name__, modname) + +#object generators: +def _build_xrange(start, step, len): + """Built xrange explicitly""" + return xrange(start, start + step*len, step) + +def _genpartial(func, args, kwds): + if not args: + args = () + if not kwds: + kwds = {} + return partial(func, *args, **kwds) + + +def _fill_function(func, globals, defaults, closure, dict): + """ Fills in the rest of function data into the skeleton function object + that were created via _make_skel_func(). + """ + func.func_globals.update(globals) + func.func_defaults = defaults + func.func_dict = dict + + if len(closure) != len(func.func_closure): + raise pickle.UnpicklingError("closure lengths don't match up") + for i in range(len(closure)): + _change_cell_value(func.func_closure[i], closure[i]) + + return func + +def _make_skel_func(code, num_closures, base_globals = None): + """ Creates a skeleton function object that contains just the provided + code and the correct number of cells in func_closure. All other + func attributes (e.g. func_globals) are empty. + """ + #build closure (cells): + if not ctypes: + raise Exception('ctypes failed to import; cannot build function') + + cellnew = ctypes.pythonapi.PyCell_New + cellnew.restype = ctypes.py_object + cellnew.argtypes = (ctypes.py_object,) + dummy_closure = tuple(map(lambda i: cellnew(None), range(num_closures))) + + if base_globals is None: + base_globals = {} + base_globals['__builtins__'] = __builtins__ + + return types.FunctionType(code, base_globals, + None, None, dummy_closure) + +# this piece of opaque code is needed below to modify 'cell' contents +cell_changer_code = new.code( + 1, 1, 2, 0, + ''.join([ + chr(dis.opmap['LOAD_FAST']), '\x00\x00', + chr(dis.opmap['DUP_TOP']), + chr(dis.opmap['STORE_DEREF']), '\x00\x00', + chr(dis.opmap['RETURN_VALUE']) + ]), + (), (), ('newval',), '', 'cell_changer', 1, '', ('c',), () +) + +def _change_cell_value(cell, newval): + """ Changes the contents of 'cell' object to newval """ + return new.function(cell_changer_code, {}, None, (), (cell,))(newval) + +"""Constructors for 3rd party libraries +Note: These can never be renamed due to client compatibility issues""" + +def _getobject(modname, attribute): + mod = __import__(modname) + return mod.__dict__[attribute] + +def _generateImage(size, mode, str_rep): + """Generate image from string representation""" + import Image + i = Image.new(mode, size) + i.fromstring(str_rep) + return i + +def _lazyloadImage(fp): + import Image + fp.seek(0) #works in almost any case + return Image.open(fp) + +"""Timeseries""" +def _genTimeSeries(reduce_args, state): + import scikits.timeseries.tseries as ts + from numpy import ndarray + from numpy.ma import MaskedArray + + + time_series = ts._tsreconstruct(*reduce_args) + + #from setstate modified + (ver, shp, typ, isf, raw, msk, flv, dsh, dtm, dtyp, frq, infodict) = state + #print 'regenerating %s' % dtyp + + MaskedArray.__setstate__(time_series, (ver, shp, typ, isf, raw, msk, flv)) + _dates = time_series._dates + #_dates.__setstate__((ver, dsh, typ, isf, dtm, frq)) #use remote typ + ndarray.__setstate__(_dates,(dsh,dtyp, isf, dtm)) + _dates.freq = frq + _dates._cachedinfo.update(dict(full=None, hasdups=None, steps=None, + toobj=None, toord=None, tostr=None)) + # Update the _optinfo dictionary + time_series._optinfo.update(infodict) + return time_series + diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index c892e86b93..5579c56de3 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,5 +1,5 @@ from base64 import standard_b64encode as b64enc -from cloud.serialization import cloudpickle +from pyspark import cloudpickle from itertools import chain from pyspark.serializers import PairSerializer, NopSerializer, \ diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 4d4cc939c3..4c4b02fce4 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -5,7 +5,7 @@ import sys from base64 import standard_b64decode # CloudPickler needs to be imported so that depicklers are registered using the # copy_reg module. -from cloud.serialization.cloudpickle import CloudPickler +from pyspark.cloudpickle import CloudPickler import cPickle diff --git a/pyspark/requirements.txt b/pyspark/requirements.txt index d9b3fe40bd..71e2bc2b89 100644 --- a/pyspark/requirements.txt +++ b/pyspark/requirements.txt @@ -4,6 +4,3 @@ # install Py4J from git once https://github.com/pypa/pip/pull/526 is merged. # git+git://github.com/bartdag/py4j.git@3dbf380d3d2cdeb9aab394454ea74d80c4aba1ea - -simplejson==2.6.1 -cloud==2.5.5 From fd94e5443c99775bfad1928729f5075c900ad0f9 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 18 Aug 2012 16:07:10 -0700 Subject: [PATCH 03/85] Use only cPickle for serialization in Python API. Objects serialized with JSON can be compared for equality, but JSON can be slow to serialize and only supports a limited range of data types. --- .../scala/spark/api/python/PythonRDD.scala | 192 ++++++-- pyspark/pyspark/context.py | 53 +-- pyspark/pyspark/java_gateway.py | 1 - pyspark/pyspark/join.py | 32 +- pyspark/pyspark/rdd.py | 422 +++++++----------- pyspark/pyspark/serializers.py | 233 +--------- pyspark/pyspark/worker.py | 64 +-- 7 files changed, 387 insertions(+), 610 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 660ad48afe..b9a0168d18 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -1,22 +1,26 @@ package spark.api.python -import java.io.PrintWriter +import java.io._ import scala.collection.Map import scala.collection.JavaConversions._ import scala.io.Source import spark._ -import api.java.{JavaPairRDD, JavaRDD} +import api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} +import scala.{collection, Some} +import collection.parallel.mutable +import scala.collection import scala.Some trait PythonRDDBase { def compute[T](split: Split, envVars: Map[String, String], - command: Seq[String], parent: RDD[T], pythonExec: String): Iterator[String]= { - val currentEnvVars = new ProcessBuilder().environment() - val SPARK_HOME = currentEnvVars.get("SPARK_HOME") + command: Seq[String], parent: RDD[T], pythonExec: String): Iterator[Array[Byte]] = { + val SPARK_HOME = new ProcessBuilder().environment().get("SPARK_HOME") val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) // Add the environmental variables to the process. + val currentEnvVars = pb.environment() + envVars.foreach { case (variable, value) => currentEnvVars.put(variable, value) } @@ -41,33 +45,70 @@ trait PythonRDDBase { for (elem <- command) { out.println(elem) } + out.flush() + val dOut = new DataOutputStream(proc.getOutputStream) for (elem <- parent.iterator(split)) { - out.println(PythonRDD.pythonDump(elem)) + if (elem.isInstanceOf[Array[Byte]]) { + val arr = elem.asInstanceOf[Array[Byte]] + dOut.writeInt(arr.length) + dOut.write(arr) + } else if (elem.isInstanceOf[scala.Tuple2[_, _]]) { + val t = elem.asInstanceOf[scala.Tuple2[_, _]] + val t1 = t._1.asInstanceOf[Array[Byte]] + val t2 = t._2.asInstanceOf[Array[Byte]] + val length = t1.length + t2.length - 3 - 3 + 4 // stripPickle() removes 3 bytes + dOut.writeInt(length) + dOut.writeByte(Pickle.PROTO) + dOut.writeByte(Pickle.TWO) + dOut.write(PythonRDD.stripPickle(t1)) + dOut.write(PythonRDD.stripPickle(t2)) + dOut.writeByte(Pickle.TUPLE2) + dOut.writeByte(Pickle.STOP) + } else if (elem.isInstanceOf[String]) { + // For uniformity, strings are wrapped into Pickles. + val s = elem.asInstanceOf[String].getBytes("UTF-8") + val length = 2 + 1 + 4 + s.length + 1 + dOut.writeInt(length) + dOut.writeByte(Pickle.PROTO) + dOut.writeByte(Pickle.TWO) + dOut.writeByte(Pickle.BINUNICODE) + dOut.writeInt(Integer.reverseBytes(s.length)) + dOut.write(s) + dOut.writeByte(Pickle.STOP) + } else { + throw new Exception("Unexpected RDD type") + } } - out.close() + dOut.flush() + out.flush() + proc.getOutputStream.close() } }.start() // Return an iterator that read lines from the process's stdout - val lines: Iterator[String] = Source.fromInputStream(proc.getInputStream).getLines - wrapIterator(lines, proc) - } + val stream = new DataInputStream(proc.getInputStream) + return new Iterator[Array[Byte]] { + def next() = { + val obj = _nextObj + _nextObj = read() + obj + } - def wrapIterator[T](iter: Iterator[T], proc: Process): Iterator[T] = { - return new Iterator[T] { - def next() = iter.next() - - def hasNext = { - if (iter.hasNext) { - true - } else { - val exitStatus = proc.waitFor() - if (exitStatus != 0) { - throw new Exception("Subprocess exited with status " + exitStatus) - } - false + private def read() = { + try { + val length = stream.readInt() + val obj = new Array[Byte](length) + stream.readFully(obj) + obj + } catch { + case eof: EOFException => { new Array[Byte](0) } + case e => throw e } } + + var _nextObj = read() + + def hasNext = _nextObj.length != 0 } } } @@ -75,7 +116,7 @@ trait PythonRDDBase { class PythonRDD[T: ClassManifest]( parent: RDD[T], command: Seq[String], envVars: Map[String, String], preservePartitoning: Boolean, pythonExec: String) - extends RDD[String](parent.context) with PythonRDDBase { + extends RDD[Array[Byte]](parent.context) with PythonRDDBase { def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = this(parent, command, Map(), preservePartitoning, pythonExec) @@ -91,16 +132,16 @@ class PythonRDD[T: ClassManifest]( override val partitioner = if (preservePartitoning) parent.partitioner else None - override def compute(split: Split): Iterator[String] = + override def compute(split: Split): Iterator[Array[Byte]] = compute(split, envVars, command, parent, pythonExec) - val asJavaRDD : JavaRDD[String] = JavaRDD.fromRDD(this) + val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } class PythonPairRDD[T: ClassManifest] ( parent: RDD[T], command: Seq[String], envVars: Map[String, String], preservePartitoning: Boolean, pythonExec: String) - extends RDD[(String, String)](parent.context) with PythonRDDBase { + extends RDD[(Array[Byte], Array[Byte])](parent.context) with PythonRDDBase { def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = this(parent, command, Map(), preservePartitoning, pythonExec) @@ -116,32 +157,95 @@ class PythonPairRDD[T: ClassManifest] ( override val partitioner = if (preservePartitoning) parent.partitioner else None - override def compute(split: Split): Iterator[(String, String)] = { + override def compute(split: Split): Iterator[(Array[Byte], Array[Byte])] = { compute(split, envVars, command, parent, pythonExec).grouped(2).map { case Seq(a, b) => (a, b) - case x => throw new Exception("Unexpected value: " + x) + case x => throw new Exception("PythonPairRDD: unexpected value: " + x) } } - val asJavaPairRDD : JavaPairRDD[String, String] = JavaPairRDD.fromRDD(this) + val asJavaPairRDD : JavaPairRDD[Array[Byte], Array[Byte]] = JavaPairRDD.fromRDD(this) } + object PythonRDD { - def pythonDump[T](x: T): String = { - if (x.isInstanceOf[scala.Option[_]]) { - val t = x.asInstanceOf[scala.Option[_]] - t match { - case None => "*" - case Some(z) => pythonDump(z) - } - } else if (x.isInstanceOf[scala.Tuple2[_, _]]) { - val t = x.asInstanceOf[scala.Tuple2[_, _]] - "(" + pythonDump(t._1) + "," + pythonDump(t._2) + ")" - } else if (x.isInstanceOf[java.util.List[_]]) { - val objs = asScalaBuffer(x.asInstanceOf[java.util.List[_]]).map(pythonDump) - "[" + objs.mkString("|") + "]" + + /** Strips the pickle PROTO and STOP opcodes from the start and end of a pickle */ + def stripPickle(arr: Array[Byte]) : Array[Byte] = { + arr.slice(2, arr.length - 1) + } + + def asPickle(elem: Any) : Array[Byte] = { + val baos = new ByteArrayOutputStream(); + val dOut = new DataOutputStream(baos); + if (elem.isInstanceOf[Array[Byte]]) { + elem.asInstanceOf[Array[Byte]] + } else if (elem.isInstanceOf[scala.Tuple2[_, _]]) { + val t = elem.asInstanceOf[scala.Tuple2[_, _]] + val t1 = t._1.asInstanceOf[Array[Byte]] + val t2 = t._2.asInstanceOf[Array[Byte]] + dOut.writeByte(Pickle.PROTO) + dOut.writeByte(Pickle.TWO) + dOut.write(PythonRDD.stripPickle(t1)) + dOut.write(PythonRDD.stripPickle(t2)) + dOut.writeByte(Pickle.TUPLE2) + dOut.writeByte(Pickle.STOP) + baos.toByteArray() + } else if (elem.isInstanceOf[String]) { + // For uniformity, strings are wrapped into Pickles. + val s = elem.asInstanceOf[String].getBytes("UTF-8") + dOut.writeByte(Pickle.PROTO) + dOut.writeByte(Pickle.TWO) + dOut.write(Pickle.BINUNICODE) + dOut.writeInt(Integer.reverseBytes(s.length)) + dOut.write(s) + dOut.writeByte(Pickle.STOP) + baos.toByteArray() } else { - x.toString + throw new Exception("Unexpected RDD type") } } + + def pickleFile(sc: JavaSparkContext, filename: String, parallelism: Int) : + JavaRDD[Array[Byte]] = { + val file = new DataInputStream(new FileInputStream(filename)) + val objs = new collection.mutable.ArrayBuffer[Array[Byte]] + try { + while (true) { + val length = file.readInt() + val obj = new Array[Byte](length) + file.readFully(obj) + objs.append(obj) + } + } catch { + case eof: EOFException => {} + case e => throw e + } + JavaRDD.fromRDD(sc.sc.parallelize(objs, parallelism)) + } + + def arrayAsPickle(arr : Any) : Array[Byte] = { + val pickles : Array[Byte] = arr.asInstanceOf[Array[Any]].map(asPickle).map(stripPickle).flatten + + Array[Byte](Pickle.PROTO, Pickle.TWO, Pickle.EMPTY_LIST, Pickle.MARK) ++ pickles ++ + Array[Byte] (Pickle.APPENDS, Pickle.STOP) + } +} + +private object Pickle { + def b(x: Int): Byte = x.asInstanceOf[Byte] + val PROTO: Byte = b(0x80) + val TWO: Byte = b(0x02) + val BINUNICODE : Byte = 'X' + val STOP : Byte = '.' + val TUPLE2 : Byte = b(0x86) + val EMPTY_LIST : Byte = ']' + val MARK : Byte = '(' + val APPENDS : Byte = 'e' +} +class ExtractValue extends spark.api.java.function.Function[(Array[Byte], + Array[Byte]), Array[Byte]] { + + override def call(pair: (Array[Byte], Array[Byte])) : Array[Byte] = pair._2 + } diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 587ab12b5f..ac7e4057e9 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -3,22 +3,24 @@ import atexit from tempfile import NamedTemporaryFile from pyspark.java_gateway import launch_gateway -from pyspark.serializers import JSONSerializer, NopSerializer -from pyspark.rdd import RDD, PairRDD +from pyspark.serializers import PickleSerializer, dumps +from pyspark.rdd import RDD class SparkContext(object): gateway = launch_gateway() jvm = gateway.jvm - python_dump = jvm.spark.api.python.PythonRDD.pythonDump + pickleFile = jvm.spark.api.python.PythonRDD.pickleFile + asPickle = jvm.spark.api.python.PythonRDD.asPickle + arrayAsPickle = jvm.spark.api.python.PythonRDD.arrayAsPickle - def __init__(self, master, name, defaultSerializer=JSONSerializer, - defaultParallelism=None, pythonExec='python'): + + def __init__(self, master, name, defaultParallelism=None, + pythonExec='python'): self.master = master self.name = name self._jsc = self.jvm.JavaSparkContext(master, name) - self.defaultSerializer = defaultSerializer self.defaultParallelism = \ defaultParallelism or self._jsc.sc().defaultParallelism() self.pythonExec = pythonExec @@ -31,39 +33,26 @@ class SparkContext(object): self._jsc.stop() self._jsc = None - def parallelize(self, c, numSlices=None, serializer=None): - serializer = serializer or self.defaultSerializer + def parallelize(self, c, numSlices=None): + """ + >>> sc = SparkContext("local", "test") + >>> rdd = sc.parallelize([(1, 2), (3, 4)]) + >>> rdd.collect() + [(1, 2), (3, 4)] + """ numSlices = numSlices or self.defaultParallelism # Calling the Java parallelize() method with an ArrayList is too slow, # because it sends O(n) Py4J commands. As an alternative, serialized # objects are written to a file and loaded through textFile(). tempFile = NamedTemporaryFile(delete=False) - tempFile.writelines(serializer.dumps(x) + '\n' for x in c) + for x in c: + dumps(PickleSerializer.dumps(x), tempFile) tempFile.close() atexit.register(lambda: os.unlink(tempFile.name)) - return self.textFile(tempFile.name, numSlices, serializer) + jrdd = self.pickleFile(self._jsc, tempFile.name, numSlices) + return RDD(jrdd, self) - def parallelizePairs(self, c, numSlices=None, keySerializer=None, - valSerializer=None): - """ - >>> sc = SparkContext("local", "test") - >>> rdd = sc.parallelizePairs([(1, 2), (3, 4)]) - >>> rdd.collect() - [(1, 2), (3, 4)] - """ - keySerializer = keySerializer or self.defaultSerializer - valSerializer = valSerializer or self.defaultSerializer - numSlices = numSlices or self.defaultParallelism - tempFile = NamedTemporaryFile(delete=False) - for (k, v) in c: - tempFile.write(keySerializer.dumps(k).rstrip('\r\n') + '\n') - tempFile.write(valSerializer.dumps(v).rstrip('\r\n') + '\n') - tempFile.close() - atexit.register(lambda: os.unlink(tempFile.name)) - jrdd = self.textFile(tempFile.name, numSlices)._pipePairs([], "echo") - return PairRDD(jrdd, self, keySerializer, valSerializer) - - def textFile(self, name, numSlices=None, serializer=NopSerializer): + def textFile(self, name, numSlices=None): numSlices = numSlices or self.defaultParallelism jrdd = self._jsc.textFile(name, numSlices) - return RDD(jrdd, self, serializer) + return RDD(jrdd, self) diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py index 2df80aee85..bcb405ba72 100644 --- a/pyspark/pyspark/java_gateway.py +++ b/pyspark/pyspark/java_gateway.py @@ -16,5 +16,4 @@ def launch_gateway(): java_import(gateway.jvm, "spark.api.java.*") java_import(gateway.jvm, "spark.api.python.*") java_import(gateway.jvm, "scala.Tuple2") - java_import(gateway.jvm, "spark.api.python.PythonRDD.pythonDump") return gateway diff --git a/pyspark/pyspark/join.py b/pyspark/pyspark/join.py index c67520fce8..7036c47980 100644 --- a/pyspark/pyspark/join.py +++ b/pyspark/pyspark/join.py @@ -30,15 +30,12 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ -from pyspark.serializers import PairSerializer, OptionSerializer, \ - ArraySerializer -def _do_python_join(rdd, other, numSplits, dispatch, valSerializer): - vs = rdd.mapPairs(lambda (k, v): (k, (1, v))) - ws = other.mapPairs(lambda (k, v): (k, (2, v))) - return vs.union(ws).groupByKey(numSplits) \ - .flatMapValues(dispatch, valSerializer) +def _do_python_join(rdd, other, numSplits, dispatch): + vs = rdd.map(lambda (k, v): (k, (1, v))) + ws = other.map(lambda (k, v): (k, (2, v))) + return vs.union(ws).groupByKey(numSplits).flatMapValues(dispatch) def python_join(rdd, other, numSplits): @@ -50,8 +47,7 @@ def python_join(rdd, other, numSplits): elif n == 2: wbuf.append(v) return [(v, w) for v in vbuf for w in wbuf] - valSerializer = PairSerializer(rdd.valSerializer, other.valSerializer) - return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + return _do_python_join(rdd, other, numSplits, dispatch) def python_right_outer_join(rdd, other, numSplits): @@ -65,9 +61,7 @@ def python_right_outer_join(rdd, other, numSplits): if not vbuf: vbuf.append(None) return [(v, w) for v in vbuf for w in wbuf] - valSerializer = PairSerializer(OptionSerializer(rdd.valSerializer), - other.valSerializer) - return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + return _do_python_join(rdd, other, numSplits, dispatch) def python_left_outer_join(rdd, other, numSplits): @@ -81,17 +75,12 @@ def python_left_outer_join(rdd, other, numSplits): if not wbuf: wbuf.append(None) return [(v, w) for v in vbuf for w in wbuf] - valSerializer = PairSerializer(rdd.valSerializer, - OptionSerializer(other.valSerializer)) - return _do_python_join(rdd, other, numSplits, dispatch, valSerializer) + return _do_python_join(rdd, other, numSplits, dispatch) def python_cogroup(rdd, other, numSplits): - resultValSerializer = PairSerializer( - ArraySerializer(rdd.valSerializer), - ArraySerializer(other.valSerializer)) - vs = rdd.mapPairs(lambda (k, v): (k, (1, v))) - ws = other.mapPairs(lambda (k, v): (k, (2, v))) + vs = rdd.map(lambda (k, v): (k, (1, v))) + ws = other.map(lambda (k, v): (k, (2, v))) def dispatch(seq): vbuf, wbuf = [], [] for (n, v) in seq: @@ -100,5 +89,4 @@ def python_cogroup(rdd, other, numSplits): elif n == 2: wbuf.append(v) return (vbuf, wbuf) - return vs.union(ws).groupByKey(numSplits) \ - .mapValues(dispatch, resultValSerializer) + return vs.union(ws).groupByKey(numSplits).mapValues(dispatch) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 5579c56de3..8eccddc0a2 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,31 +1,17 @@ from base64 import standard_b64encode as b64enc -from pyspark import cloudpickle -from itertools import chain -from pyspark.serializers import PairSerializer, NopSerializer, \ - OptionSerializer, ArraySerializer +from pyspark import cloudpickle +from pyspark.serializers import PickleSerializer from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup class RDD(object): - def __init__(self, jrdd, ctx, serializer=None): + def __init__(self, jrdd, ctx): self._jrdd = jrdd self.is_cached = False self.ctx = ctx - self.serializer = serializer or ctx.defaultSerializer - - def _builder(self, jrdd, ctx): - return RDD(jrdd, ctx, self.serializer) - - @property - def id(self): - return self._jrdd.id() - - @property - def splits(self): - return self._jrdd.splits() @classmethod def _get_pipe_command(cls, command, functions): @@ -41,55 +27,18 @@ class RDD(object): self._jrdd.cache() return self - def map(self, f, serializer=None, preservesPartitioning=False): - return MappedRDD(self, f, serializer, preservesPartitioning) + def map(self, f, preservesPartitioning=False): + return MappedRDD(self, f, preservesPartitioning) - def mapPairs(self, f, keySerializer=None, valSerializer=None, - preservesPartitioning=False): - return PairMappedRDD(self, f, keySerializer, valSerializer, - preservesPartitioning) - - def flatMap(self, f, serializer=None): + def flatMap(self, f): """ >>> rdd = sc.parallelize([2, 3, 4]) >>> sorted(rdd.flatMap(lambda x: range(1, x)).collect()) [1, 1, 1, 2, 2, 3] - """ - serializer = serializer or self.ctx.defaultSerializer - dumps = serializer.dumps - loads = self.serializer.loads - def func(x): - pickled_elems = (dumps(y) for y in f(loads(x))) - return "\n".join(pickled_elems) or None - pipe_command = RDD._get_pipe_command("map", [func]) - class_manifest = self._jrdd.classManifest() - jrdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, - False, self.ctx.pythonExec, - class_manifest).asJavaRDD() - return RDD(jrdd, self.ctx, serializer) - - def flatMapPairs(self, f, keySerializer=None, valSerializer=None, - preservesPartitioning=False): - """ - >>> rdd = sc.parallelize([2, 3, 4]) - >>> sorted(rdd.flatMapPairs(lambda x: [(x, x), (x, x)]).collect()) + >>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect()) [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] """ - keySerializer = keySerializer or self.ctx.defaultSerializer - valSerializer = valSerializer or self.ctx.defaultSerializer - dumpk = keySerializer.dumps - dumpv = valSerializer.dumps - loads = self.serializer.loads - def func(x): - pairs = f(loads(x)) - pickled_pairs = ((dumpk(k), dumpv(v)) for (k, v) in pairs) - return "\n".join(chain.from_iterable(pickled_pairs)) or None - pipe_command = RDD._get_pipe_command("map", [func]) - class_manifest = self._jrdd.classManifest() - python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), pipe_command, - preservesPartitioning, self.ctx.pythonExec, class_manifest) - return PairRDD(python_rdd.asJavaPairRDD(), self.ctx, keySerializer, - valSerializer) + return MappedRDD(self, f, preservesPartitioning=False, command='flatmap') def filter(self, f): """ @@ -97,9 +46,8 @@ class RDD(object): >>> rdd.filter(lambda x: x % 2 == 0).collect() [2, 4] """ - loads = self.serializer.loads - def filter_func(x): return x if f(loads(x)) else None - return self._builder(self._pipe(filter_func), self.ctx) + def filter_func(x): return x if f(x) else None + return RDD(self._pipe(filter_func), self.ctx) def _pipe(self, functions, command="map"): class_manifest = self._jrdd.classManifest() @@ -108,32 +56,22 @@ class RDD(object): False, self.ctx.pythonExec, class_manifest) return python_rdd.asJavaRDD() - def _pipePairs(self, functions, command="mapPairs", - preservesPartitioning=False): - class_manifest = self._jrdd.classManifest() - pipe_command = RDD._get_pipe_command(command, functions) - python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), pipe_command, - preservesPartitioning, self.ctx.pythonExec, class_manifest) - return python_rdd.asJavaPairRDD() - def distinct(self): """ >>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect()) [1, 2, 3] """ - if self.serializer.is_comparable: - return self._builder(self._jrdd.distinct(), self.ctx) - return self.mapPairs(lambda x: (x, "")) \ + return self.map(lambda x: (x, "")) \ .reduceByKey(lambda x, _: x) \ .map(lambda (x, _): x) def sample(self, withReplacement, fraction, seed): jrdd = self._jrdd.sample(withReplacement, fraction, seed) - return self._builder(jrdd, self.ctx) + return RDD(jrdd, self.ctx) def takeSample(self, withReplacement, num, seed): vals = self._jrdd.takeSample(withReplacement, num, seed) - return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + return [PickleSerializer.loads(x) for x in vals] def union(self, other): """ @@ -141,7 +79,7 @@ class RDD(object): >>> rdd.union(rdd).collect() [1, 1, 2, 3, 1, 1, 2, 3] """ - return self._builder(self._jrdd.union(other._jrdd), self.ctx) + return RDD(self._jrdd.union(other._jrdd), self.ctx) # TODO: sort @@ -155,16 +93,17 @@ class RDD(object): >>> sorted(rdd.cartesian(rdd).collect()) [(1, 1), (1, 2), (2, 1), (2, 2)] """ - return PairRDD(self._jrdd.cartesian(other._jrdd), self.ctx) + return RDD(self._jrdd.cartesian(other._jrdd), self.ctx) # numsplits def groupBy(self, f, numSplits=None): """ >>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8]) - >>> sorted(rdd.groupBy(lambda x: x % 2).collect()) + >>> result = rdd.groupBy(lambda x: x % 2).collect() + >>> sorted([(x, sorted(y)) for (x, y) in result]) [(0, [2, 8]), (1, [1, 1, 3, 5])] """ - return self.mapPairs(lambda x: (f(x), x)).groupByKey(numSplits) + return self.map(lambda x: (f(x), x)).groupByKey(numSplits) # TODO: pipe @@ -178,25 +117,19 @@ class RDD(object): self.map(f).collect() # Force evaluation def collect(self): - vals = self._jrdd.collect() - return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().collect()) + return PickleSerializer.loads(bytes(pickle)) - def reduce(self, f, serializer=None): + def reduce(self, f): """ - >>> import operator - >>> sc.parallelize([1, 2, 3, 4, 5]).reduce(operator.add) + >>> from operator import add + >>> sc.parallelize([1, 2, 3, 4, 5]).reduce(add) 15 + >>> sc.parallelize((2 for _ in range(10))).map(lambda x: 1).cache().reduce(add) + 10 """ - serializer = serializer or self.ctx.defaultSerializer - loads = self.serializer.loads - dumps = serializer.dumps - def reduceFunction(x, acc): - if acc is None: - return loads(x) - else: - return f(loads(x), acc) - vals = self._pipe([reduceFunction, dumps], command="reduce").collect() - return reduce(f, (serializer.loads(x) for x in vals)) + vals = MappedRDD(self, f, command="reduce", preservesPartitioning=False).collect() + return reduce(f, vals) # TODO: fold @@ -216,36 +149,35 @@ class RDD(object): >>> sc.parallelize([2, 3, 4]).take(2) [2, 3] """ - vals = self._jrdd.take(num) - return [self.serializer.loads(self.ctx.python_dump(x)) for x in vals] + pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().take(num)) + return PickleSerializer.loads(bytes(pickle)) def first(self): """ >>> sc.parallelize([2, 3, 4]).first() 2 """ - return self.serializer.loads(self.ctx.python_dump(self._jrdd.first())) + return PickleSerializer.loads(bytes(self.ctx.asPickle(self._jrdd.first()))) # TODO: saveAsTextFile # TODO: saveAsObjectFile + # Pair functions -class PairRDD(RDD): - - def __init__(self, jrdd, ctx, keySerializer=None, valSerializer=None): - RDD.__init__(self, jrdd, ctx) - self.keySerializer = keySerializer or ctx.defaultSerializer - self.valSerializer = valSerializer or ctx.defaultSerializer - self.serializer = \ - PairSerializer(self.keySerializer, self.valSerializer) - - def _builder(self, jrdd, ctx): - return PairRDD(jrdd, ctx, self.keySerializer, self.valSerializer) + def collectAsMap(self): + """ + >>> m = sc.parallelize([(1, 2), (3, 4)]).collectAsMap() + >>> m[1] + 2 + >>> m[3] + 4 + """ + return dict(self.collect()) def reduceByKey(self, func, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(x.reduceByKey(lambda a, b: a + b).collect()) [('a', 2), ('b', 1)] """ @@ -259,90 +191,67 @@ class PairRDD(RDD): def join(self, other, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) - >>> y = sc.parallelizePairs([("a", 2), ("a", 3)]) - >>> x.join(y).collect() + >>> x = sc.parallelize([("a", 1), ("b", 4)]) + >>> y = sc.parallelize([("a", 2), ("a", 3)]) + >>> sorted(x.join(y).collect()) [('a', (1, 2)), ('a', (1, 3))] - - Check that we get a PairRDD-like object back: - >>> assert x.join(y).join """ - assert self.keySerializer.name == other.keySerializer.name - if self.keySerializer.is_comparable: - return PairRDD(self._jrdd.join(other._jrdd), - self.ctx, self.keySerializer, - PairSerializer(self.valSerializer, other.valSerializer)) - else: - return python_join(self, other, numSplits) + return python_join(self, other, numSplits) def leftOuterJoin(self, other, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) - >>> y = sc.parallelizePairs([("a", 2)]) + >>> x = sc.parallelize([("a", 1), ("b", 4)]) + >>> y = sc.parallelize([("a", 2)]) >>> sorted(x.leftOuterJoin(y).collect()) [('a', (1, 2)), ('b', (4, None))] """ - assert self.keySerializer.name == other.keySerializer.name - if self.keySerializer.is_comparable: - return PairRDD(self._jrdd.leftOuterJoin(other._jrdd), - self.ctx, self.keySerializer, - PairSerializer(self.valSerializer, - OptionSerializer(other.valSerializer))) - else: - return python_left_outer_join(self, other, numSplits) + return python_left_outer_join(self, other, numSplits) def rightOuterJoin(self, other, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) - >>> y = sc.parallelizePairs([("a", 2)]) + >>> x = sc.parallelize([("a", 1), ("b", 4)]) + >>> y = sc.parallelize([("a", 2)]) >>> sorted(y.rightOuterJoin(x).collect()) [('a', (2, 1)), ('b', (None, 4))] """ - assert self.keySerializer.name == other.keySerializer.name - if self.keySerializer.is_comparable: - return PairRDD(self._jrdd.rightOuterJoin(other._jrdd), - self.ctx, self.keySerializer, - PairSerializer(OptionSerializer(self.valSerializer), - other.valSerializer)) - else: - return python_right_outer_join(self, other, numSplits) + return python_right_outer_join(self, other, numSplits) + + # TODO: pipelining + # TODO: optimizations + def shuffle(self, numSplits): + if numSplits is None: + numSplits = self.ctx.defaultParallelism + pipe_command = RDD._get_pipe_command('shuffle_map_step', []) + class_manifest = self._jrdd.classManifest() + python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), + pipe_command, False, self.ctx.pythonExec, class_manifest) + partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) + jrdd = python_rdd.asJavaPairRDD().partitionBy(partitioner) + jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) + # TODO: extract second value. + return RDD(jrdd, self.ctx) + + def combineByKey(self, createCombiner, mergeValue, mergeCombiners, - numSplits=None, serializer=None): + numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> def f(x): return x >>> def add(a, b): return a + str(b) >>> sorted(x.combineByKey(str, add, add).collect()) [('a', '11'), ('b', '1')] """ - serializer = serializer or self.ctx.defaultSerializer if numSplits is None: numSplits = self.ctx.defaultParallelism - # Use hash() to create keys that are comparable in Java. - loadkv = self.serializer.loads - def pairify(kv): - # TODO: add method to deserialize only the key or value from - # a PairSerializer? - key = loadkv(kv)[0] - return (str(hash(key)), kv) - partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) - jrdd = self._pipePairs(pairify).partitionBy(partitioner) - pairified = PairRDD(jrdd, self.ctx, NopSerializer, self.serializer) - - loads = PairSerializer(NopSerializer, self.serializer).loads - dumpk = self.keySerializer.dumps - dumpc = serializer.dumps - - functions = [createCombiner, mergeValue, mergeCombiners, loads, dumpk, - dumpc] - jpairs = pairified._pipePairs(functions, "combine_by_key", - preservesPartitioning=True) - return PairRDD(jpairs, self.ctx, self.keySerializer, serializer) + shuffled = self.shuffle(numSplits) + functions = [createCombiner, mergeValue, mergeCombiners] + jpairs = shuffled._pipe(functions, "combine_by_key") + return RDD(jpairs, self.ctx) def groupByKey(self, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 1), ("a", 1)]) + >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(x.groupByKey().collect()) [('a', [1, 1]), ('b', [1])] """ @@ -360,29 +269,15 @@ class PairRDD(RDD): return self.combineByKey(createCombiner, mergeValue, mergeCombiners, numSplits) - def collectAsMap(self): - """ - >>> m = sc.parallelizePairs([(1, 2), (3, 4)]).collectAsMap() - >>> m[1] - 2 - >>> m[3] - 4 - """ - m = self._jrdd.collectAsMap() - def loads(x): - (k, v) = x - return (self.keySerializer.loads(k), self.valSerializer.loads(v)) - return dict(loads(x) for x in m.items()) - - def flatMapValues(self, f, valSerializer=None): + def flatMapValues(self, f): flat_map_fn = lambda (k, v): ((k, x) for x in f(v)) - return self.flatMapPairs(flat_map_fn, self.keySerializer, - valSerializer, True) + return self.flatMap(flat_map_fn) - def mapValues(self, f, valSerializer=None): + def mapValues(self, f): map_values_fn = lambda (k, v): (k, f(v)) - return self.mapPairs(map_values_fn, self.keySerializer, valSerializer, - True) + return self.map(map_values_fn, preservesPartitioning=True) + + # TODO: implement shuffle. # TODO: support varargs cogroup of several RDDs. def groupWith(self, other): @@ -390,20 +285,12 @@ class PairRDD(RDD): def cogroup(self, other, numSplits=None): """ - >>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) - >>> y = sc.parallelizePairs([("a", 2)]) + >>> x = sc.parallelize([("a", 1), ("b", 4)]) + >>> y = sc.parallelize([("a", 2)]) >>> x.cogroup(y).collect() [('a', ([1], [2])), ('b', ([4], []))] """ - assert self.keySerializer.name == other.keySerializer.name - resultValSerializer = PairSerializer( - ArraySerializer(self.valSerializer), - ArraySerializer(other.valSerializer)) - if self.keySerializer.is_comparable: - return PairRDD(self._jrdd.cogroup(other._jrdd), - self.ctx, self.keySerializer, resultValSerializer) - else: - return python_cogroup(self, other, numSplits) + return python_cogroup(self, other, numSplits) # TODO: `lookup` is disabled because we can't make direct comparisons based # on the key; we need to compare the hash of the key to the hash of the @@ -413,44 +300,84 @@ class PairRDD(RDD): # TODO: file saving -class MappedRDDBase(object): - def __init__(self, prev, func, serializer, preservesPartitioning=False): - if isinstance(prev, MappedRDDBase) and not prev.is_cached: - prev_func = prev.func - self.func = lambda x: func(prev_func(x)) - self.preservesPartitioning = \ - prev.preservesPartitioning and preservesPartitioning - self._prev_jrdd = prev._prev_jrdd - self._prev_serializer = prev._prev_serializer - else: - self.func = func - self.preservesPartitioning = preservesPartitioning - self._prev_jrdd = prev._jrdd - self._prev_serializer = prev.serializer - self.serializer = serializer or prev.ctx.defaultSerializer - self.is_cached = False - self.ctx = prev.ctx - self.prev = prev - self._jrdd_val = None - - -class MappedRDD(MappedRDDBase, RDD): +class MappedRDD(RDD): """ + Pipelined maps: >>> rdd = sc.parallelize([1, 2, 3, 4]) >>> rdd.map(lambda x: 2 * x).cache().map(lambda x: 2 * x).collect() [4, 8, 12, 16] >>> rdd.map(lambda x: 2 * x).map(lambda x: 2 * x).collect() [4, 8, 12, 16] + + Pipelined reduces: + >>> from operator import add + >>> rdd.map(lambda x: 2 * x).reduce(add) + 20 + >>> rdd.flatMap(lambda x: [x, x]).reduce(add) + 20 """ + def __init__(self, prev, func, preservesPartitioning=False, command='map'): + if isinstance(prev, MappedRDD) and not prev.is_cached: + prev_func = prev.func + if command == 'reduce': + if prev.command == 'flatmap': + def flatmap_reduce_func(x, acc): + values = prev_func(x) + if values is None: + return acc + if not acc: + if len(values) == 1: + return values[0] + else: + return reduce(func, values[1:], values[0]) + else: + return reduce(func, values, acc) + self.func = flatmap_reduce_func + else: + def reduce_func(x, acc): + val = prev_func(x) + if not val: + return acc + if acc is None: + return val + else: + return func(val, acc) + self.func = reduce_func + else: + if prev.command == 'flatmap': + command = 'flatmap' + self.func = lambda x: (func(y) for y in prev_func(x)) + else: + self.func = lambda x: func(prev_func(x)) + + self.preservesPartitioning = \ + prev.preservesPartitioning and preservesPartitioning + self._prev_jrdd = prev._prev_jrdd + self.is_pipelined = True + else: + if command == 'reduce': + def reduce_func(val, acc): + if acc is None: + return val + else: + return func(val, acc) + self.func = reduce_func + else: + self.func = func + self.preservesPartitioning = preservesPartitioning + self._prev_jrdd = prev._jrdd + self.is_pipelined = False + self.is_cached = False + self.ctx = prev.ctx + self.prev = prev + self._jrdd_val = None + self.command = command @property def _jrdd(self): if not self._jrdd_val: - udf = self.func - loads = self._prev_serializer.loads - dumps = self.serializer.dumps - func = lambda x: dumps(udf(loads(x))) - pipe_command = RDD._get_pipe_command("map", [func]) + funcs = [self.func] + pipe_command = RDD._get_pipe_command(self.command, funcs) class_manifest = self._prev_jrdd.classManifest() python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), pipe_command, self.preservesPartitioning, self.ctx.pythonExec, @@ -459,56 +386,11 @@ class MappedRDD(MappedRDDBase, RDD): return self._jrdd_val -class PairMappedRDD(MappedRDDBase, PairRDD): - """ - >>> rdd = sc.parallelize([1, 2, 3, 4]) - >>> rdd.mapPairs(lambda x: (x, x)) \\ - ... .mapPairs(lambda (x, y): (2*x, 2*y)) \\ - ... .collect() - [(2, 2), (4, 4), (6, 6), (8, 8)] - >>> rdd.mapPairs(lambda x: (x, x)) \\ - ... .mapPairs(lambda (x, y): (2*x, 2*y)) \\ - ... .map(lambda (x, _): x).collect() - [2, 4, 6, 8] - """ - - def __init__(self, prev, func, keySerializer=None, valSerializer=None, - preservesPartitioning=False): - self.keySerializer = keySerializer or prev.ctx.defaultSerializer - self.valSerializer = valSerializer or prev.ctx.defaultSerializer - serializer = PairSerializer(self.keySerializer, self.valSerializer) - MappedRDDBase.__init__(self, prev, func, serializer, - preservesPartitioning) - - @property - def _jrdd(self): - if not self._jrdd_val: - udf = self.func - loads = self._prev_serializer.loads - dumpk = self.keySerializer.dumps - dumpv = self.valSerializer.dumps - def func(x): - (k, v) = udf(loads(x)) - return (dumpk(k), dumpv(v)) - pipe_command = RDD._get_pipe_command("mapPairs", [func]) - class_manifest = self._prev_jrdd.classManifest() - self._jrdd_val = self.ctx.jvm.PythonPairRDD(self._prev_jrdd.rdd(), - pipe_command, self.preservesPartitioning, self.ctx.pythonExec, - class_manifest).asJavaPairRDD() - return self._jrdd_val - - def _test(): import doctest from pyspark.context import SparkContext - from pyspark.serializers import PickleSerializer, JSONSerializer globs = globals().copy() - globs['sc'] = SparkContext('local', 'PythonTest', - defaultSerializer=JSONSerializer) - doctest.testmod(globs=globs) - globs['sc'].stop() - globs['sc'] = SparkContext('local', 'PythonTest', - defaultSerializer=PickleSerializer) + globs['sc'] = SparkContext('local', 'PythonTest') doctest.testmod(globs=globs) globs['sc'].stop() diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index b113f5656b..7b3e6966e1 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -2,228 +2,35 @@ Data serialization methods. The Spark Python API is built on top of the Spark Java API. RDDs created in -Python are stored in Java as RDDs of Strings. Python objects are automatically -serialized/deserialized, so this representation is transparent to the end-user. - ------------------- -Serializer objects ------------------- - -`Serializer` objects are used to customize how an RDD's values are serialized. - -Each `Serializer` is a named tuple with four fields: - - - A `dumps` function, for serializing a Python object to a string. - - - A `loads` function, for deserializing a Python object from a string. - - - An `is_comparable` field, True if equal Python objects are serialized to - equal strings, and False otherwise. - - - A `name` field, used to identify the Serializer. Serializers are - compared for equality by comparing their names. - -The serializer's output should be base64-encoded. - ------------------------------------------------------------------- -`is_comparable`: comparing serialized representations for equality ------------------------------------------------------------------- - -If `is_comparable` is False, the serializer's representations of equal objects -are not required to be equal: - ->>> import pickle ->>> a = {1: 0, 9: 0} ->>> b = {9: 0, 1: 0} ->>> a == b -True ->>> pickle.dumps(a) == pickle.dumps(b) -False - -RDDs with comparable serializers can use native Java implementations of -operations like join() and distinct(), which may lead to better performance by -eliminating deserialization and Python comparisons. - -The default JSONSerializer produces comparable representations of common Python -data structures. - --------------------------------------- -Examples of serialized representations --------------------------------------- - -The RDD transformations that use Python UDFs are implemented in terms of -a modified `PipedRDD.pipe()` function. For each record `x` in the RDD, the -`pipe()` function pipes `x.toString()` to a Python worker process, which -deserializes the string into a Python object, executes user-defined functions, -and outputs serialized Python objects. - -The regular `toString()` method returns an ambiguous representation, due to the -way that Scala `Option` instances are printed: - ->>> from context import SparkContext ->>> sc = SparkContext("local", "SerializerDocs") ->>> x = sc.parallelizePairs([("a", 1), ("b", 4)]) ->>> y = sc.parallelizePairs([("a", 2)]) - ->>> print y.rightOuterJoin(x)._jrdd.first().toString() -(ImEi,(Some(Mg==),MQ==)) - -In Java, preprocessing is performed to handle Option instances, so the Python -process receives unambiguous input: - ->>> print sc.python_dump(y.rightOuterJoin(x)._jrdd.first()) -(ImEi,(Mg==,MQ==)) - -The base64-encoding eliminates the need to escape newlines, parentheses and -other special characters. - ----------------------- -Serializer composition ----------------------- - -In order to handle nested structures, which could contain object serialized -with different serializers, the RDD module composes serializers. For example, -the serializers in the previous example are: - ->>> print x.serializer.name -PairSerializer - ->>> print y.serializer.name -PairSerializer - ->>> print y.rightOuterJoin(x).serializer.name -PairSerializer, JSONSerializer>> +Python are stored in Java as RDD[Array[Byte]]. Python objects are +automatically serialized/deserialized, so this representation is transparent to +the end-user. """ -from base64 import standard_b64encode, standard_b64decode from collections import namedtuple import cPickle -import simplejson +import struct -Serializer = namedtuple("Serializer", - ["dumps","loads", "is_comparable", "name"]) - - -NopSerializer = Serializer(str, str, True, "NopSerializer") - - -JSONSerializer = Serializer( - lambda obj: standard_b64encode(simplejson.dumps(obj, sort_keys=True, - separators=(',', ':'))), - lambda s: simplejson.loads(standard_b64decode(s)), - True, - "JSONSerializer" -) +Serializer = namedtuple("Serializer", ["dumps","loads"]) PickleSerializer = Serializer( - lambda obj: standard_b64encode(cPickle.dumps(obj)), - lambda s: cPickle.loads(standard_b64decode(s)), - False, - "PickleSerializer" -) + lambda obj: cPickle.dumps(obj, -1), + cPickle.loads) -def OptionSerializer(serializer): - """ - >>> ser = OptionSerializer(NopSerializer) - >>> ser.loads(ser.dumps("Hello, World!")) - 'Hello, World!' - >>> ser.loads(ser.dumps(None)) is None - True - """ - none_placeholder = '*' - - def dumps(x): - if x is None: - return none_placeholder - else: - return serializer.dumps(x) - - def loads(x): - if x == none_placeholder: - return None - else: - return serializer.loads(x) - - name = "OptionSerializer<%s>" % serializer.name - return Serializer(dumps, loads, serializer.is_comparable, name) +def dumps(obj, stream): + # TODO: determining the length of non-byte objects. + stream.write(struct.pack("!i", len(obj))) + stream.write(obj) -def PairSerializer(keySerializer, valSerializer): - """ - Returns a Serializer for a (key, value) pair. - - >>> ser = PairSerializer(JSONSerializer, JSONSerializer) - >>> ser.loads(ser.dumps((1, 2))) - (1, 2) - - >>> ser = PairSerializer(JSONSerializer, ser) - >>> ser.loads(ser.dumps((1, (2, 3)))) - (1, (2, 3)) - """ - def loads(kv): - try: - (key, val) = kv[1:-1].split(',', 1) - key = keySerializer.loads(key) - val = valSerializer.loads(val) - return (key, val) - except: - print "Error in deserializing pair from '%s'" % str(kv) - raise - - def dumps(kv): - (key, val) = kv - return"(%s,%s)" % (keySerializer.dumps(key), valSerializer.dumps(val)) - is_comparable = \ - keySerializer.is_comparable and valSerializer.is_comparable - name = "PairSerializer<%s, %s>" % (keySerializer.name, valSerializer.name) - return Serializer(dumps, loads, is_comparable, name) - - -def ArraySerializer(serializer): - """ - >>> ser = ArraySerializer(JSONSerializer) - >>> ser.loads(ser.dumps([1, 2, 3, 4])) - [1, 2, 3, 4] - >>> ser = ArraySerializer(PairSerializer(JSONSerializer, PickleSerializer)) - >>> ser.loads(ser.dumps([('a', 1), ('b', 2)])) - [('a', 1), ('b', 2)] - >>> ser.loads(ser.dumps([('a', 1)])) - [('a', 1)] - >>> ser.loads(ser.dumps([])) - [] - """ - def dumps(arr): - if arr == []: - return '[]' - else: - return '[' + '|'.join(serializer.dumps(x) for x in arr) + ']' - - def loads(s): - if s == '[]': - return [] - items = s[1:-1] - if '|' in items: - items = items.split('|') - else: - items = [items] - return [serializer.loads(x) for x in items] - - name = "ArraySerializer<%s>" % serializer.name - return Serializer(dumps, loads, serializer.is_comparable, name) - - -# TODO: IntegerSerializer - - -# TODO: DoubleSerializer - - -def _test(): - import doctest - doctest.testmod() - - -if __name__ == "__main__": - _test() +def loads(stream): + length = stream.read(4) + if length == "": + raise EOFError + length = struct.unpack("!i", length)[0] + obj = stream.read(length) + if obj == "": + raise EOFError + return obj diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 4c4b02fce4..21ff84fb17 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -6,9 +6,9 @@ from base64 import standard_b64decode # CloudPickler needs to be imported so that depicklers are registered using the # copy_reg module. from pyspark.cloudpickle import CloudPickler +from pyspark.serializers import dumps, loads, PickleSerializer import cPickle - # Redirect stdout to stderr so that users must return values from functions. old_stdout = sys.stdout sys.stdout = sys.stderr @@ -19,58 +19,64 @@ def load_function(): def output(x): - for line in x.split("\n"): - old_stdout.write(line.rstrip("\r\n") + "\n") + dumps(x, old_stdout) def read_input(): - for line in sys.stdin: - yield line.rstrip("\r\n") - + try: + while True: + yield loads(sys.stdin) + except EOFError: + return def do_combine_by_key(): create_combiner = load_function() merge_value = load_function() merge_combiners = load_function() # TODO: not used. - depickler = load_function() - key_pickler = load_function() - combiner_pickler = load_function() combiners = {} - for line in read_input(): - # Discard the hashcode added in the Python combineByKey() method. - (key, value) = depickler(line)[1] + for obj in read_input(): + (key, value) = PickleSerializer.loads(obj) if key not in combiners: combiners[key] = create_combiner(value) else: combiners[key] = merge_value(combiners[key], value) for (key, combiner) in combiners.iteritems(): - output(key_pickler(key)) - output(combiner_pickler(combiner)) + output(PickleSerializer.dumps((key, combiner))) -def do_map(map_pairs=False): +def do_map(flat=False): f = load_function() - for line in read_input(): + for obj in read_input(): try: - out = f(line) + #from pickletools import dis + #print repr(obj) + #print dis(obj) + out = f(PickleSerializer.loads(obj)) if out is not None: - if map_pairs: + if flat: for x in out: - output(x) + output(PickleSerializer.dumps(x)) else: - output(out) + output(PickleSerializer.dumps(out)) except: - sys.stderr.write("Error processing line '%s'\n" % line) + sys.stderr.write("Error processing obj %s\n" % repr(obj)) raise +def do_shuffle_map_step(): + for obj in read_input(): + key = PickleSerializer.loads(obj)[1] + output(str(hash(key))) + output(obj) + + def do_reduce(): f = load_function() - dumps = load_function() acc = None - for line in read_input(): - acc = f(line, acc) - output(dumps(acc)) + for obj in read_input(): + acc = f(PickleSerializer.loads(obj), acc) + if acc is not None: + output(PickleSerializer.dumps(acc)) def do_echo(): @@ -80,13 +86,15 @@ def do_echo(): def main(): command = sys.stdin.readline().strip() if command == "map": - do_map(map_pairs=False) - elif command == "mapPairs": - do_map(map_pairs=True) + do_map(flat=False) + elif command == "flatmap": + do_map(flat=True) elif command == "combine_by_key": do_combine_by_key() elif command == "reduce": do_reduce() + elif command == "shuffle_map_step": + do_shuffle_map_step() elif command == "echo": do_echo() else: From 607b53abfca049e7d9139e2d29893a3bb252de19 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Wed, 22 Aug 2012 00:43:55 -0700 Subject: [PATCH 04/85] Use numpy in Python k-means example. --- .../scala/spark/api/python/PythonRDD.scala | 8 ++++++- pyspark/pyspark/examples/kmeans.py | 23 +++++++------------ pyspark/pyspark/rdd.py | 9 +++----- pyspark/pyspark/worker.py | 8 +++---- 4 files changed, 21 insertions(+), 27 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index b9a0168d18..93847e2f14 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -101,7 +101,13 @@ trait PythonRDDBase { stream.readFully(obj) obj } catch { - case eof: EOFException => { new Array[Byte](0) } + case eof: EOFException => { + val exitStatus = proc.waitFor() + if (exitStatus != 0) { + throw new Exception("Subprocess exited with status " + exitStatus) + } + new Array[Byte](0) + } case e => throw e } } diff --git a/pyspark/pyspark/examples/kmeans.py b/pyspark/pyspark/examples/kmeans.py index 0761d6e395..9cc366f03c 100644 --- a/pyspark/pyspark/examples/kmeans.py +++ b/pyspark/pyspark/examples/kmeans.py @@ -1,25 +1,18 @@ import sys from pyspark.context import SparkContext +from numpy import array, sum as np_sum def parseVector(line): - return [float(x) for x in line.split(' ')] - - -def addVec(x, y): - return [a + b for (a, b) in zip(x, y)] - - -def squaredDist(x, y): - return sum((a - b) ** 2 for (a, b) in zip(x, y)) + return array([float(x) for x in line.split(' ')]) def closestPoint(p, centers): bestIndex = 0 closest = float("+inf") for i in range(len(centers)): - tempDist = squaredDist(p, centers[i]) + tempDist = np_sum((p - centers[i]) ** 2) if tempDist < closest: closest = tempDist bestIndex = i @@ -41,14 +34,14 @@ if __name__ == "__main__": tempDist = 1.0 while tempDist > convergeDist: - closest = data.mapPairs( + closest = data.map( lambda p : (closestPoint(p, kPoints), (p, 1))) pointStats = closest.reduceByKey( - lambda (x1, y1), (x2, y2): (addVec(x1, x2), y1 + y2)) - newPoints = pointStats.mapPairs( - lambda (x, (y, z)): (x, [a / z for a in y])).collect() + lambda (x1, y1), (x2, y2): (x1 + x2, y1 + y2)) + newPoints = pointStats.map( + lambda (x, (y, z)): (x, y / z)).collect() - tempDist = sum(squaredDist(kPoints[x], y) for (x, y) in newPoints) + tempDist = sum(np_sum((kPoints[x] - y) ** 2) for (x, y) in newPoints) for (x, y) in newPoints: kPoints[x] = y diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 8eccddc0a2..ff9c483032 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -71,7 +71,7 @@ class RDD(object): def takeSample(self, withReplacement, num, seed): vals = self._jrdd.takeSample(withReplacement, num, seed) - return [PickleSerializer.loads(x) for x in vals] + return [PickleSerializer.loads(bytes(x)) for x in vals] def union(self, other): """ @@ -218,17 +218,16 @@ class RDD(object): # TODO: pipelining # TODO: optimizations - def shuffle(self, numSplits): + def shuffle(self, numSplits, hashFunc=hash): if numSplits is None: numSplits = self.ctx.defaultParallelism - pipe_command = RDD._get_pipe_command('shuffle_map_step', []) + pipe_command = RDD._get_pipe_command('shuffle_map_step', [hashFunc]) class_manifest = self._jrdd.classManifest() python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), pipe_command, False, self.ctx.pythonExec, class_manifest) partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) jrdd = python_rdd.asJavaPairRDD().partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) - # TODO: extract second value. return RDD(jrdd, self.ctx) @@ -277,8 +276,6 @@ class RDD(object): map_values_fn = lambda (k, v): (k, f(v)) return self.map(map_values_fn, preservesPartitioning=True) - # TODO: implement shuffle. - # TODO: support varargs cogroup of several RDDs. def groupWith(self, other): return self.cogroup(other) diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 21ff84fb17..b13ed5699a 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -48,9 +48,6 @@ def do_map(flat=False): f = load_function() for obj in read_input(): try: - #from pickletools import dis - #print repr(obj) - #print dis(obj) out = f(PickleSerializer.loads(obj)) if out is not None: if flat: @@ -64,9 +61,10 @@ def do_map(flat=False): def do_shuffle_map_step(): + hashFunc = load_function() for obj in read_input(): - key = PickleSerializer.loads(obj)[1] - output(str(hash(key))) + key = PickleSerializer.loads(obj)[0] + output(str(hashFunc(key))) output(obj) From 4b523004877cf94152225484de7683e9d17cdb56 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 23 Aug 2012 15:54:15 -0700 Subject: [PATCH 05/85] Fix options parsing in Python pi example. --- pyspark/pyspark/examples/pi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyspark/pyspark/examples/pi.py b/pyspark/pyspark/examples/pi.py index ad77694c41..fe63d2c952 100644 --- a/pyspark/pyspark/examples/pi.py +++ b/pyspark/pyspark/examples/pi.py @@ -10,7 +10,7 @@ if __name__ == "__main__": "Usage: PythonPi []" exit(-1) sc = SparkContext(sys.argv[1], "PythonKMeans") - slices = sys.argv[2] if len(sys.argv) > 2 else 2 + slices = int(sys.argv[2]) if len(sys.argv) > 2 else 2 n = 100000 * slices def f(_): x = random() * 2 - 1 From f3b852ce66d193e3421eeecef71ea27bff73a94b Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 24 Aug 2012 19:38:50 -0700 Subject: [PATCH 06/85] Refactor Python MappedRDD to use iterator pipelines. --- pyspark/pyspark/rdd.py | 83 ++++++++++++--------------------------- pyspark/pyspark/worker.py | 55 +++++++------------------- 2 files changed, 41 insertions(+), 97 deletions(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index ff9c483032..7d280d8844 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,4 +1,5 @@ from base64 import standard_b64encode as b64enc +from itertools import chain, ifilter, imap from pyspark import cloudpickle from pyspark.serializers import PickleSerializer @@ -15,8 +16,6 @@ class RDD(object): @classmethod def _get_pipe_command(cls, command, functions): - if functions and not isinstance(functions, (list, tuple)): - functions = [functions] worker_args = [command] for f in functions: worker_args.append(b64enc(cloudpickle.dumps(f))) @@ -28,7 +27,8 @@ class RDD(object): return self def map(self, f, preservesPartitioning=False): - return MappedRDD(self, f, preservesPartitioning) + def func(iterator): return imap(f, iterator) + return PipelinedRDD(self, func, preservesPartitioning) def flatMap(self, f): """ @@ -38,7 +38,8 @@ class RDD(object): >>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect()) [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] """ - return MappedRDD(self, f, preservesPartitioning=False, command='flatmap') + def func(iterator): return chain.from_iterable(imap(f, iterator)) + return PipelinedRDD(self, func) def filter(self, f): """ @@ -46,10 +47,10 @@ class RDD(object): >>> rdd.filter(lambda x: x % 2 == 0).collect() [2, 4] """ - def filter_func(x): return x if f(x) else None - return RDD(self._pipe(filter_func), self.ctx) + def func(iterator): return ifilter(f, iterator) + return PipelinedRDD(self, func) - def _pipe(self, functions, command="map"): + def _pipe(self, functions, command): class_manifest = self._jrdd.classManifest() pipe_command = RDD._get_pipe_command(command, functions) python_rdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, @@ -128,7 +129,16 @@ class RDD(object): >>> sc.parallelize((2 for _ in range(10))).map(lambda x: 1).cache().reduce(add) 10 """ - vals = MappedRDD(self, f, command="reduce", preservesPartitioning=False).collect() + def func(iterator): + acc = None + for obj in iterator: + if acc is None: + acc = obj + else: + acc = f(obj, acc) + if acc is not None: + yield acc + vals = PipelinedRDD(self, func).collect() return reduce(f, vals) # TODO: fold @@ -230,8 +240,6 @@ class RDD(object): jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) return RDD(jrdd, self.ctx) - - def combineByKey(self, createCombiner, mergeValue, mergeCombiners, numSplits=None): """ @@ -297,7 +305,7 @@ class RDD(object): # TODO: file saving -class MappedRDD(RDD): +class PipelinedRDD(RDD): """ Pipelined maps: >>> rdd = sc.parallelize([1, 2, 3, 4]) @@ -313,68 +321,29 @@ class MappedRDD(RDD): >>> rdd.flatMap(lambda x: [x, x]).reduce(add) 20 """ - def __init__(self, prev, func, preservesPartitioning=False, command='map'): - if isinstance(prev, MappedRDD) and not prev.is_cached: + def __init__(self, prev, func, preservesPartitioning=False): + if isinstance(prev, PipelinedRDD) and not prev.is_cached: prev_func = prev.func - if command == 'reduce': - if prev.command == 'flatmap': - def flatmap_reduce_func(x, acc): - values = prev_func(x) - if values is None: - return acc - if not acc: - if len(values) == 1: - return values[0] - else: - return reduce(func, values[1:], values[0]) - else: - return reduce(func, values, acc) - self.func = flatmap_reduce_func - else: - def reduce_func(x, acc): - val = prev_func(x) - if not val: - return acc - if acc is None: - return val - else: - return func(val, acc) - self.func = reduce_func - else: - if prev.command == 'flatmap': - command = 'flatmap' - self.func = lambda x: (func(y) for y in prev_func(x)) - else: - self.func = lambda x: func(prev_func(x)) - + def pipeline_func(iterator): + return func(prev_func(iterator)) + self.func = pipeline_func self.preservesPartitioning = \ prev.preservesPartitioning and preservesPartitioning self._prev_jrdd = prev._prev_jrdd - self.is_pipelined = True else: - if command == 'reduce': - def reduce_func(val, acc): - if acc is None: - return val - else: - return func(val, acc) - self.func = reduce_func - else: - self.func = func + self.func = func self.preservesPartitioning = preservesPartitioning self._prev_jrdd = prev._jrdd - self.is_pipelined = False self.is_cached = False self.ctx = prev.ctx self.prev = prev self._jrdd_val = None - self.command = command @property def _jrdd(self): if not self._jrdd_val: funcs = [self.func] - pipe_command = RDD._get_pipe_command(self.command, funcs) + pipe_command = RDD._get_pipe_command("pipeline", funcs) class_manifest = self._prev_jrdd.classManifest() python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), pipe_command, self.preservesPartitioning, self.ctx.pythonExec, diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index b13ed5699a..76b09918e7 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -25,17 +25,17 @@ def output(x): def read_input(): try: while True: - yield loads(sys.stdin) + yield cPickle.loads(loads(sys.stdin)) except EOFError: return + def do_combine_by_key(): create_combiner = load_function() merge_value = load_function() merge_combiners = load_function() # TODO: not used. combiners = {} - for obj in read_input(): - (key, value) = PickleSerializer.loads(obj) + for (key, value) in read_input(): if key not in combiners: combiners[key] = create_combiner(value) else: @@ -44,57 +44,32 @@ def do_combine_by_key(): output(PickleSerializer.dumps((key, combiner))) -def do_map(flat=False): +def do_pipeline(): f = load_function() - for obj in read_input(): - try: - out = f(PickleSerializer.loads(obj)) - if out is not None: - if flat: - for x in out: - output(PickleSerializer.dumps(x)) - else: - output(PickleSerializer.dumps(out)) - except: - sys.stderr.write("Error processing obj %s\n" % repr(obj)) - raise + for obj in f(read_input()): + output(PickleSerializer.dumps(obj)) def do_shuffle_map_step(): hashFunc = load_function() - for obj in read_input(): - key = PickleSerializer.loads(obj)[0] + while True: + try: + pickled = loads(sys.stdin) + except EOFError: + return + key = cPickle.loads(pickled)[0] output(str(hashFunc(key))) - output(obj) - - -def do_reduce(): - f = load_function() - acc = None - for obj in read_input(): - acc = f(PickleSerializer.loads(obj), acc) - if acc is not None: - output(PickleSerializer.dumps(acc)) - - -def do_echo(): - old_stdout.writelines(sys.stdin.readlines()) + output(pickled) def main(): command = sys.stdin.readline().strip() - if command == "map": - do_map(flat=False) - elif command == "flatmap": - do_map(flat=True) + if command == "pipeline": + do_pipeline() elif command == "combine_by_key": do_combine_by_key() - elif command == "reduce": - do_reduce() elif command == "shuffle_map_step": do_shuffle_map_step() - elif command == "echo": - do_echo() else: raise Exception("Unsupported command %s" % command) From 65e8406029a0fe1e1c5c5d033d335b43f6743a04 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 24 Aug 2012 21:07:26 -0700 Subject: [PATCH 07/85] Implement fold() in Python API. --- pyspark/pyspark/rdd.py | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 7d280d8844..af7703fdfc 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -141,7 +141,25 @@ class RDD(object): vals = PipelinedRDD(self, func).collect() return reduce(f, vals) - # TODO: fold + def fold(self, zeroValue, op): + """ + Aggregate the elements of each partition, and then the results for all + the partitions, using a given associative function and a neutral "zero + value." The function op(t1, t2) is allowed to modify t1 and return it + as its result value to avoid object allocation; however, it should not + modify t2. + + >>> from operator import add + >>> sc.parallelize([1, 2, 3, 4, 5]).fold(0, add) + 15 + """ + def func(iterator): + acc = zeroValue + for obj in iterator: + acc = op(obj, acc) + yield acc + vals = PipelinedRDD(self, func).collect() + return reduce(op, vals, zeroValue) # TODO: aggregate From f79a1e4d2a8643157136de69b8d7de84f0034712 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 25 Aug 2012 13:59:01 -0700 Subject: [PATCH 08/85] Add broadcast variables to Python API. --- .../scala/spark/api/python/PythonRDD.scala | 43 ++++++++++------- pyspark/pyspark/broadcast.py | 46 +++++++++++++++++++ pyspark/pyspark/context.py | 17 +++++-- pyspark/pyspark/rdd.py | 27 +++++++---- pyspark/pyspark/worker.py | 6 +++ 5 files changed, 110 insertions(+), 29 deletions(-) create mode 100644 pyspark/pyspark/broadcast.py diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 93847e2f14..5163812df4 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -7,14 +7,13 @@ import scala.collection.JavaConversions._ import scala.io.Source import spark._ import api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} -import scala.{collection, Some} -import collection.parallel.mutable +import broadcast.Broadcast import scala.collection -import scala.Some trait PythonRDDBase { def compute[T](split: Split, envVars: Map[String, String], - command: Seq[String], parent: RDD[T], pythonExec: String): Iterator[Array[Byte]] = { + command: Seq[String], parent: RDD[T], pythonExec: String, + broadcastVars: java.util.List[Broadcast[Array[Byte]]]): Iterator[Array[Byte]] = { val SPARK_HOME = new ProcessBuilder().environment().get("SPARK_HOME") val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) @@ -42,11 +41,18 @@ trait PythonRDDBase { override def run() { SparkEnv.set(env) val out = new PrintWriter(proc.getOutputStream) + val dOut = new DataOutputStream(proc.getOutputStream) + out.println(broadcastVars.length) + for (broadcast <- broadcastVars) { + out.print(broadcast.uuid.toString) + dOut.writeInt(broadcast.value.length) + dOut.write(broadcast.value) + dOut.flush() + } for (elem <- command) { out.println(elem) } out.flush() - val dOut = new DataOutputStream(proc.getOutputStream) for (elem <- parent.iterator(split)) { if (elem.isInstanceOf[Array[Byte]]) { val arr = elem.asInstanceOf[Array[Byte]] @@ -121,16 +127,17 @@ trait PythonRDDBase { class PythonRDD[T: ClassManifest]( parent: RDD[T], command: Seq[String], envVars: Map[String, String], - preservePartitoning: Boolean, pythonExec: String) + preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) extends RDD[Array[Byte]](parent.context) with PythonRDDBase { - def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = - this(parent, command, Map(), preservePartitoning, pythonExec) + def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, + pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, command, Map(), preservePartitoning, pythonExec, broadcastVars) // Similar to Runtime.exec(), if we are given a single string, split it into words // using a standard StringTokenizer (i.e. by spaces) - def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String) = - this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec) + def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec, broadcastVars) override def splits = parent.splits @@ -139,23 +146,25 @@ class PythonRDD[T: ClassManifest]( override val partitioner = if (preservePartitoning) parent.partitioner else None override def compute(split: Split): Iterator[Array[Byte]] = - compute(split, envVars, command, parent, pythonExec) + compute(split, envVars, command, parent, pythonExec, broadcastVars) val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } class PythonPairRDD[T: ClassManifest] ( parent: RDD[T], command: Seq[String], envVars: Map[String, String], - preservePartitoning: Boolean, pythonExec: String) + preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) extends RDD[(Array[Byte], Array[Byte])](parent.context) with PythonRDDBase { - def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, pythonExec: String) = - this(parent, command, Map(), preservePartitoning, pythonExec) + def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, + pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, command, Map(), preservePartitoning, pythonExec, broadcastVars) // Similar to Runtime.exec(), if we are given a single string, split it into words // using a standard StringTokenizer (i.e. by spaces) - def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String) = - this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec) + def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String, + broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec, broadcastVars) override def splits = parent.splits @@ -164,7 +173,7 @@ class PythonPairRDD[T: ClassManifest] ( override val partitioner = if (preservePartitoning) parent.partitioner else None override def compute(split: Split): Iterator[(Array[Byte], Array[Byte])] = { - compute(split, envVars, command, parent, pythonExec).grouped(2).map { + compute(split, envVars, command, parent, pythonExec, broadcastVars).grouped(2).map { case Seq(a, b) => (a, b) case x => throw new Exception("PythonPairRDD: unexpected value: " + x) } diff --git a/pyspark/pyspark/broadcast.py b/pyspark/pyspark/broadcast.py new file mode 100644 index 0000000000..1ea17d59af --- /dev/null +++ b/pyspark/pyspark/broadcast.py @@ -0,0 +1,46 @@ +""" +>>> from pyspark.context import SparkContext +>>> sc = SparkContext('local', 'test') +>>> b = sc.broadcast([1, 2, 3, 4, 5]) +>>> b.value +[1, 2, 3, 4, 5] + +>>> from pyspark.broadcast import _broadcastRegistry +>>> _broadcastRegistry[b.uuid] = b +>>> from cPickle import dumps, loads +>>> loads(dumps(b)).value +[1, 2, 3, 4, 5] + +>>> sc.parallelize([0, 0]).flatMap(lambda x: b.value).collect() +[1, 2, 3, 4, 5, 1, 2, 3, 4, 5] +""" +# Holds broadcasted data received from Java, keyed by UUID. +_broadcastRegistry = {} + + +def _from_uuid(uuid): + from pyspark.broadcast import _broadcastRegistry + if uuid not in _broadcastRegistry: + raise Exception("Broadcast variable '%s' not loaded!" % uuid) + return _broadcastRegistry[uuid] + + +class Broadcast(object): + def __init__(self, uuid, value, java_broadcast=None, pickle_registry=None): + self.value = value + self.uuid = uuid + self._jbroadcast = java_broadcast + self._pickle_registry = pickle_registry + + def __reduce__(self): + self._pickle_registry.add(self) + return (_from_uuid, (self.uuid, )) + + +def _test(): + import doctest + doctest.testmod() + + +if __name__ == "__main__": + _test() diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index ac7e4057e9..6f87206665 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -2,6 +2,7 @@ import os import atexit from tempfile import NamedTemporaryFile +from pyspark.broadcast import Broadcast from pyspark.java_gateway import launch_gateway from pyspark.serializers import PickleSerializer, dumps from pyspark.rdd import RDD @@ -24,6 +25,11 @@ class SparkContext(object): self.defaultParallelism = \ defaultParallelism or self._jsc.sc().defaultParallelism() self.pythonExec = pythonExec + # Broadcast's __reduce__ method stores Broadcast instances here. + # This allows other code to determine which Broadcast instances have + # been pickled, so it can determine which Java broadcast objects to + # send. + self._pickled_broadcast_vars = set() def __del__(self): if self._jsc: @@ -52,7 +58,12 @@ class SparkContext(object): jrdd = self.pickleFile(self._jsc, tempFile.name, numSlices) return RDD(jrdd, self) - def textFile(self, name, numSlices=None): - numSlices = numSlices or self.defaultParallelism - jrdd = self._jsc.textFile(name, numSlices) + def textFile(self, name, minSplits=None): + minSplits = minSplits or min(self.defaultParallelism, 2) + jrdd = self._jsc.textFile(name, minSplits) return RDD(jrdd, self) + + def broadcast(self, value): + jbroadcast = self._jsc.broadcast(bytearray(PickleSerializer.dumps(value))) + return Broadcast(jbroadcast.uuid().toString(), value, jbroadcast, + self._pickled_broadcast_vars) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index af7703fdfc..4459095391 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -6,6 +6,8 @@ from pyspark.serializers import PickleSerializer from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup +from py4j.java_collections import ListConverter + class RDD(object): @@ -15,11 +17,15 @@ class RDD(object): self.ctx = ctx @classmethod - def _get_pipe_command(cls, command, functions): + def _get_pipe_command(cls, ctx, command, functions): worker_args = [command] for f in functions: worker_args.append(b64enc(cloudpickle.dumps(f))) - return " ".join(worker_args) + broadcast_vars = [x._jbroadcast for x in ctx._pickled_broadcast_vars] + broadcast_vars = ListConverter().convert(broadcast_vars, + ctx.gateway._gateway_client) + ctx._pickled_broadcast_vars.clear() + return (" ".join(worker_args), broadcast_vars) def cache(self): self.is_cached = True @@ -52,9 +58,10 @@ class RDD(object): def _pipe(self, functions, command): class_manifest = self._jrdd.classManifest() - pipe_command = RDD._get_pipe_command(command, functions) + (pipe_command, broadcast_vars) = \ + RDD._get_pipe_command(self.ctx, command, functions) python_rdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, - False, self.ctx.pythonExec, class_manifest) + False, self.ctx.pythonExec, broadcast_vars, class_manifest) return python_rdd.asJavaRDD() def distinct(self): @@ -249,10 +256,12 @@ class RDD(object): def shuffle(self, numSplits, hashFunc=hash): if numSplits is None: numSplits = self.ctx.defaultParallelism - pipe_command = RDD._get_pipe_command('shuffle_map_step', [hashFunc]) + (pipe_command, broadcast_vars) = \ + RDD._get_pipe_command(self.ctx, 'shuffle_map_step', [hashFunc]) class_manifest = self._jrdd.classManifest() python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), - pipe_command, False, self.ctx.pythonExec, class_manifest) + pipe_command, False, self.ctx.pythonExec, broadcast_vars, + class_manifest) partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) jrdd = python_rdd.asJavaPairRDD().partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) @@ -360,12 +369,12 @@ class PipelinedRDD(RDD): @property def _jrdd(self): if not self._jrdd_val: - funcs = [self.func] - pipe_command = RDD._get_pipe_command("pipeline", funcs) + (pipe_command, broadcast_vars) = \ + RDD._get_pipe_command(self.ctx, "pipeline", [self.func]) class_manifest = self._prev_jrdd.classManifest() python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), pipe_command, self.preservesPartitioning, self.ctx.pythonExec, - class_manifest) + broadcast_vars, class_manifest) self._jrdd_val = python_rdd.asJavaRDD() return self._jrdd_val diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 76b09918e7..7402897ac8 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -5,6 +5,7 @@ import sys from base64 import standard_b64decode # CloudPickler needs to be imported so that depicklers are registered using the # copy_reg module. +from pyspark.broadcast import Broadcast, _broadcastRegistry from pyspark.cloudpickle import CloudPickler from pyspark.serializers import dumps, loads, PickleSerializer import cPickle @@ -63,6 +64,11 @@ def do_shuffle_map_step(): def main(): + num_broadcast_variables = int(sys.stdin.readline().strip()) + for _ in range(num_broadcast_variables): + uuid = sys.stdin.read(36) + value = loads(sys.stdin) + _broadcastRegistry[uuid] = Broadcast(uuid, cPickle.loads(value)) command = sys.stdin.readline().strip() if command == "pipeline": do_pipeline() From 08b201d810c0dc0933d00d78ec2c1d9135e100c3 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 24 Aug 2012 22:51:45 -0700 Subject: [PATCH 09/85] Add mapPartitions(), glom(), countByValue() to Python API. --- pyspark/pyspark/rdd.py | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 4459095391..f0d665236a 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,4 +1,5 @@ from base64 import standard_b64encode as b64enc +from collections import Counter from itertools import chain, ifilter, imap from pyspark import cloudpickle @@ -47,6 +48,15 @@ class RDD(object): def func(iterator): return chain.from_iterable(imap(f, iterator)) return PipelinedRDD(self, func) + def mapPartitions(self, f): + """ + >>> rdd = sc.parallelize([1, 2, 3, 4], 2) + >>> def f(iterator): yield sum(iterator) + >>> rdd.mapPartitions(f).collect() + [3, 7] + """ + return PipelinedRDD(self, f) + def filter(self, f): """ >>> rdd = sc.parallelize([1, 2, 3, 4, 5]) @@ -93,7 +103,14 @@ class RDD(object): # TODO: Overload __add___? - # TODO: glom + def glom(self): + """ + >>> rdd = sc.parallelize([1, 2, 3, 4], 2) + >>> rdd.glom().first() + [1, 2] + """ + def func(iterator): yield list(iterator) + return PipelinedRDD(self, func) def cartesian(self, other): """ @@ -115,8 +132,6 @@ class RDD(object): # TODO: pipe - # TODO: mapPartitions - def foreach(self, f): """ >>> def f(x): print x @@ -177,7 +192,16 @@ class RDD(object): """ return self._jrdd.count() - # TODO: count approx methods + def countByValue(self): + """ + >>> sc.parallelize([1, 2, 1, 2, 2]).countByValue().most_common() + [(2, 3), (1, 2)] + """ + def countPartition(iterator): + yield Counter(iterator) + def mergeMaps(m1, m2): + return m1 + m2 + return self.mapPartitions(countPartition).reduce(mergeMaps) def take(self, num): """ From 8b64b7ecd80c52f2f09a517f1517c0ece7a3d57f Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 24 Aug 2012 23:09:15 -0700 Subject: [PATCH 10/85] Add countByKey(), reduceByKeyLocally() to Python API --- pyspark/pyspark/rdd.py | 52 +++++++++++++++++++++++++++++++----------- 1 file changed, 39 insertions(+), 13 deletions(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index f0d665236a..fd41ea0b17 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -99,9 +99,17 @@ class RDD(object): """ return RDD(self._jrdd.union(other._jrdd), self.ctx) - # TODO: sort + def __add__(self, other): + """ + >>> rdd = sc.parallelize([1, 1, 2, 3]) + >>> (rdd + rdd).collect() + [1, 1, 2, 3, 1, 1, 2, 3] + """ + if not isinstance(other, RDD): + raise TypeError + return self.union(other) - # TODO: Overload __add___? + # TODO: sort def glom(self): """ @@ -120,7 +128,6 @@ class RDD(object): """ return RDD(self._jrdd.cartesian(other._jrdd), self.ctx) - # numsplits def groupBy(self, f, numSplits=None): """ >>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8]) @@ -236,17 +243,38 @@ class RDD(object): def reduceByKey(self, func, numSplits=None): """ - >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) - >>> sorted(x.reduceByKey(lambda a, b: a + b).collect()) + >>> from operator import add + >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) + >>> sorted(rdd.reduceByKey(add).collect()) [('a', 2), ('b', 1)] """ return self.combineByKey(lambda x: x, func, func, numSplits) - # TODO: reduceByKeyLocally() + def reduceByKeyLocally(self, func): + """ + >>> from operator import add + >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) + >>> sorted(rdd.reduceByKeyLocally(add).items()) + [('a', 2), ('b', 1)] + """ + def reducePartition(iterator): + m = {} + for (k, v) in iterator: + m[k] = v if k not in m else func(m[k], v) + yield m + def mergeMaps(m1, m2): + for (k, v) in m2.iteritems(): + m1[k] = v if k not in m1 else func(m1[k], v) + return m1 + return self.mapPartitions(reducePartition).reduce(mergeMaps) - # TODO: countByKey() - - # TODO: partitionBy + def countByKey(self): + """ + >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) + >>> rdd.countByKey().most_common() + [('a', 2), ('b', 1)] + """ + return self.map(lambda x: x[0]).countByValue() def join(self, other, numSplits=None): """ @@ -277,7 +305,7 @@ class RDD(object): # TODO: pipelining # TODO: optimizations - def shuffle(self, numSplits, hashFunc=hash): + def partitionBy(self, numSplits, hashFunc=hash): if numSplits is None: numSplits = self.ctx.defaultParallelism (pipe_command, broadcast_vars) = \ @@ -302,7 +330,7 @@ class RDD(object): """ if numSplits is None: numSplits = self.ctx.defaultParallelism - shuffled = self.shuffle(numSplits) + shuffled = self.partitionBy(numSplits) functions = [createCombiner, mergeValue, mergeCombiners] jpairs = shuffled._pipe(functions, "combine_by_key") return RDD(jpairs, self.ctx) @@ -353,8 +381,6 @@ class RDD(object): # keys in the pairs. This could be an expensive operation, since those # hashes aren't retained. - # TODO: file saving - class PipelinedRDD(RDD): """ From 6904cb77d4306a14891cc71338c8f9f966d009f1 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 25 Aug 2012 14:19:07 -0700 Subject: [PATCH 11/85] Use local combiners in Python API combineByKey(). --- pyspark/pyspark/rdd.py | 33 ++++++++++++++++++++++++--------- pyspark/pyspark/worker.py | 16 ---------------- 2 files changed, 24 insertions(+), 25 deletions(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index fd41ea0b17..3528b8f308 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -46,7 +46,7 @@ class RDD(object): [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] """ def func(iterator): return chain.from_iterable(imap(f, iterator)) - return PipelinedRDD(self, func) + return self.mapPartitions(func) def mapPartitions(self, f): """ @@ -64,7 +64,7 @@ class RDD(object): [2, 4] """ def func(iterator): return ifilter(f, iterator) - return PipelinedRDD(self, func) + return self.mapPartitions(func) def _pipe(self, functions, command): class_manifest = self._jrdd.classManifest() @@ -118,7 +118,7 @@ class RDD(object): [1, 2] """ def func(iterator): yield list(iterator) - return PipelinedRDD(self, func) + return self.mapPartitions(func) def cartesian(self, other): """ @@ -167,7 +167,7 @@ class RDD(object): acc = f(obj, acc) if acc is not None: yield acc - vals = PipelinedRDD(self, func).collect() + vals = self.mapPartitions(func).collect() return reduce(f, vals) def fold(self, zeroValue, op): @@ -187,7 +187,7 @@ class RDD(object): for obj in iterator: acc = op(obj, acc) yield acc - vals = PipelinedRDD(self, func).collect() + vals = self.mapPartitions(func).collect() return reduce(op, vals, zeroValue) # TODO: aggregate @@ -330,10 +330,25 @@ class RDD(object): """ if numSplits is None: numSplits = self.ctx.defaultParallelism - shuffled = self.partitionBy(numSplits) - functions = [createCombiner, mergeValue, mergeCombiners] - jpairs = shuffled._pipe(functions, "combine_by_key") - return RDD(jpairs, self.ctx) + def combineLocally(iterator): + combiners = {} + for (k, v) in iterator: + if k not in combiners: + combiners[k] = createCombiner(v) + else: + combiners[k] = mergeValue(combiners[k], v) + return combiners.iteritems() + locally_combined = self.mapPartitions(combineLocally) + shuffled = locally_combined.partitionBy(numSplits) + def _mergeCombiners(iterator): + combiners = {} + for (k, v) in iterator: + if not k in combiners: + combiners[k] = v + else: + combiners[k] = mergeCombiners(combiners[k], v) + return combiners.iteritems() + return shuffled.mapPartitions(_mergeCombiners) def groupByKey(self, numSplits=None): """ diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 7402897ac8..0f90c6ff46 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -31,20 +31,6 @@ def read_input(): return -def do_combine_by_key(): - create_combiner = load_function() - merge_value = load_function() - merge_combiners = load_function() # TODO: not used. - combiners = {} - for (key, value) in read_input(): - if key not in combiners: - combiners[key] = create_combiner(value) - else: - combiners[key] = merge_value(combiners[key], value) - for (key, combiner) in combiners.iteritems(): - output(PickleSerializer.dumps((key, combiner))) - - def do_pipeline(): f = load_function() for obj in f(read_input()): @@ -72,8 +58,6 @@ def main(): command = sys.stdin.readline().strip() if command == "pipeline": do_pipeline() - elif command == "combine_by_key": - do_combine_by_key() elif command == "shuffle_map_step": do_shuffle_map_step() else: From 200d248dcc5903295296bf897211cf543b37f8c1 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 25 Aug 2012 16:46:07 -0700 Subject: [PATCH 12/85] Simplify Python worker; pipeline the map step of partitionBy(). --- .../scala/spark/api/python/PythonRDD.scala | 34 ++------- pyspark/pyspark/context.py | 9 ++- pyspark/pyspark/rdd.py | 70 +++++++------------ pyspark/pyspark/serializers.py | 23 ++---- pyspark/pyspark/worker.py | 50 ++++--------- 5 files changed, 59 insertions(+), 127 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 5163812df4..b9091fd436 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -151,38 +151,18 @@ class PythonRDD[T: ClassManifest]( val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } -class PythonPairRDD[T: ClassManifest] ( - parent: RDD[T], command: Seq[String], envVars: Map[String, String], - preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) - extends RDD[(Array[Byte], Array[Byte])](parent.context) with PythonRDDBase { - - def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, - pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = - this(parent, command, Map(), preservePartitoning, pythonExec, broadcastVars) - - // Similar to Runtime.exec(), if we are given a single string, split it into words - // using a standard StringTokenizer (i.e. by spaces) - def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String, - broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = - this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec, broadcastVars) - - override def splits = parent.splits - - override val dependencies = List(new OneToOneDependency(parent)) - - override val partitioner = if (preservePartitoning) parent.partitioner else None - - override def compute(split: Split): Iterator[(Array[Byte], Array[Byte])] = { - compute(split, envVars, command, parent, pythonExec, broadcastVars).grouped(2).map { +private class PairwiseRDD(prev: RDD[Array[Byte]]) extends + RDD[(Array[Byte], Array[Byte])](prev.context) { + override def splits = prev.splits + override val dependencies = List(new OneToOneDependency(prev)) + override def compute(split: Split) = + prev.iterator(split).grouped(2).map { case Seq(a, b) => (a, b) - case x => throw new Exception("PythonPairRDD: unexpected value: " + x) + case x => throw new Exception("PairwiseRDD: unexpected value: " + x) } - } - val asJavaPairRDD : JavaPairRDD[Array[Byte], Array[Byte]] = JavaPairRDD.fromRDD(this) } - object PythonRDD { /** Strips the pickle PROTO and STOP opcodes from the start and end of a pickle */ diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 6f87206665..b8490019e3 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -4,7 +4,7 @@ from tempfile import NamedTemporaryFile from pyspark.broadcast import Broadcast from pyspark.java_gateway import launch_gateway -from pyspark.serializers import PickleSerializer, dumps +from pyspark.serializers import dump_pickle, write_with_length from pyspark.rdd import RDD @@ -16,9 +16,8 @@ class SparkContext(object): asPickle = jvm.spark.api.python.PythonRDD.asPickle arrayAsPickle = jvm.spark.api.python.PythonRDD.arrayAsPickle - def __init__(self, master, name, defaultParallelism=None, - pythonExec='python'): + pythonExec='python'): self.master = master self.name = name self._jsc = self.jvm.JavaSparkContext(master, name) @@ -52,7 +51,7 @@ class SparkContext(object): # objects are written to a file and loaded through textFile(). tempFile = NamedTemporaryFile(delete=False) for x in c: - dumps(PickleSerializer.dumps(x), tempFile) + write_with_length(dump_pickle(x), tempFile) tempFile.close() atexit.register(lambda: os.unlink(tempFile.name)) jrdd = self.pickleFile(self._jsc, tempFile.name, numSlices) @@ -64,6 +63,6 @@ class SparkContext(object): return RDD(jrdd, self) def broadcast(self, value): - jbroadcast = self._jsc.broadcast(bytearray(PickleSerializer.dumps(value))) + jbroadcast = self._jsc.broadcast(bytearray(dump_pickle(value))) return Broadcast(jbroadcast.uuid().toString(), value, jbroadcast, self._pickled_broadcast_vars) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 3528b8f308..21e822ba9f 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -3,7 +3,7 @@ from collections import Counter from itertools import chain, ifilter, imap from pyspark import cloudpickle -from pyspark.serializers import PickleSerializer +from pyspark.serializers import dump_pickle, load_pickle from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup @@ -17,17 +17,6 @@ class RDD(object): self.is_cached = False self.ctx = ctx - @classmethod - def _get_pipe_command(cls, ctx, command, functions): - worker_args = [command] - for f in functions: - worker_args.append(b64enc(cloudpickle.dumps(f))) - broadcast_vars = [x._jbroadcast for x in ctx._pickled_broadcast_vars] - broadcast_vars = ListConverter().convert(broadcast_vars, - ctx.gateway._gateway_client) - ctx._pickled_broadcast_vars.clear() - return (" ".join(worker_args), broadcast_vars) - def cache(self): self.is_cached = True self._jrdd.cache() @@ -66,14 +55,6 @@ class RDD(object): def func(iterator): return ifilter(f, iterator) return self.mapPartitions(func) - def _pipe(self, functions, command): - class_manifest = self._jrdd.classManifest() - (pipe_command, broadcast_vars) = \ - RDD._get_pipe_command(self.ctx, command, functions) - python_rdd = self.ctx.jvm.PythonRDD(self._jrdd.rdd(), pipe_command, - False, self.ctx.pythonExec, broadcast_vars, class_manifest) - return python_rdd.asJavaRDD() - def distinct(self): """ >>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect()) @@ -89,7 +70,7 @@ class RDD(object): def takeSample(self, withReplacement, num, seed): vals = self._jrdd.takeSample(withReplacement, num, seed) - return [PickleSerializer.loads(bytes(x)) for x in vals] + return [load_pickle(bytes(x)) for x in vals] def union(self, other): """ @@ -148,7 +129,7 @@ class RDD(object): def collect(self): pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().collect()) - return PickleSerializer.loads(bytes(pickle)) + return load_pickle(bytes(pickle)) def reduce(self, f): """ @@ -216,19 +197,17 @@ class RDD(object): [2, 3] """ pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().take(num)) - return PickleSerializer.loads(bytes(pickle)) + return load_pickle(bytes(pickle)) def first(self): """ >>> sc.parallelize([2, 3, 4]).first() 2 """ - return PickleSerializer.loads(bytes(self.ctx.asPickle(self._jrdd.first()))) + return load_pickle(bytes(self.ctx.asPickle(self._jrdd.first()))) # TODO: saveAsTextFile - # TODO: saveAsObjectFile - # Pair functions def collectAsMap(self): @@ -303,19 +282,18 @@ class RDD(object): """ return python_right_outer_join(self, other, numSplits) - # TODO: pipelining - # TODO: optimizations def partitionBy(self, numSplits, hashFunc=hash): if numSplits is None: numSplits = self.ctx.defaultParallelism - (pipe_command, broadcast_vars) = \ - RDD._get_pipe_command(self.ctx, 'shuffle_map_step', [hashFunc]) - class_manifest = self._jrdd.classManifest() - python_rdd = self.ctx.jvm.PythonPairRDD(self._jrdd.rdd(), - pipe_command, False, self.ctx.pythonExec, broadcast_vars, - class_manifest) + def add_shuffle_key(iterator): + for (k, v) in iterator: + yield str(hashFunc(k)) + yield dump_pickle((k, v)) + keyed = PipelinedRDD(self, add_shuffle_key) + keyed._bypass_serializer = True + pairRDD = self.ctx.jvm.PairwiseRDD(keyed._jrdd.rdd()).asJavaPairRDD() partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) - jrdd = python_rdd.asJavaPairRDD().partitionBy(partitioner) + jrdd = pairRDD.partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) return RDD(jrdd, self.ctx) @@ -430,17 +408,23 @@ class PipelinedRDD(RDD): self.ctx = prev.ctx self.prev = prev self._jrdd_val = None + self._bypass_serializer = False @property def _jrdd(self): - if not self._jrdd_val: - (pipe_command, broadcast_vars) = \ - RDD._get_pipe_command(self.ctx, "pipeline", [self.func]) - class_manifest = self._prev_jrdd.classManifest() - python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), - pipe_command, self.preservesPartitioning, self.ctx.pythonExec, - broadcast_vars, class_manifest) - self._jrdd_val = python_rdd.asJavaRDD() + if self._jrdd_val: + return self._jrdd_val + funcs = [self.func, self._bypass_serializer] + pipe_command = ' '.join(b64enc(cloudpickle.dumps(f)) for f in funcs) + broadcast_vars = ListConverter().convert( + [x._jbroadcast for x in self.ctx._pickled_broadcast_vars], + self.ctx.gateway._gateway_client) + self.ctx._pickled_broadcast_vars.clear() + class_manifest = self._prev_jrdd.classManifest() + python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), + pipe_command, self.preservesPartitioning, self.ctx.pythonExec, + broadcast_vars, class_manifest) + self._jrdd_val = python_rdd.asJavaRDD() return self._jrdd_val diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index 7b3e6966e1..faa1e683c7 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -1,31 +1,20 @@ -""" -Data serialization methods. - -The Spark Python API is built on top of the Spark Java API. RDDs created in -Python are stored in Java as RDD[Array[Byte]]. Python objects are -automatically serialized/deserialized, so this representation is transparent to -the end-user. -""" -from collections import namedtuple -import cPickle import struct +import cPickle -Serializer = namedtuple("Serializer", ["dumps","loads"]) +def dump_pickle(obj): + return cPickle.dumps(obj, 2) -PickleSerializer = Serializer( - lambda obj: cPickle.dumps(obj, -1), - cPickle.loads) +load_pickle = cPickle.loads -def dumps(obj, stream): - # TODO: determining the length of non-byte objects. +def write_with_length(obj, stream): stream.write(struct.pack("!i", len(obj))) stream.write(obj) -def loads(stream): +def read_with_length(stream): length = stream.read(4) if length == "": raise EOFError diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 0f90c6ff46..a9ed71892f 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -7,61 +7,41 @@ from base64 import standard_b64decode # copy_reg module. from pyspark.broadcast import Broadcast, _broadcastRegistry from pyspark.cloudpickle import CloudPickler -from pyspark.serializers import dumps, loads, PickleSerializer -import cPickle +from pyspark.serializers import write_with_length, read_with_length, \ + dump_pickle, load_pickle + # Redirect stdout to stderr so that users must return values from functions. old_stdout = sys.stdout sys.stdout = sys.stderr -def load_function(): - return cPickle.loads(standard_b64decode(sys.stdin.readline().strip())) - - -def output(x): - dumps(x, old_stdout) +def load_obj(): + return load_pickle(standard_b64decode(sys.stdin.readline().strip())) def read_input(): try: while True: - yield cPickle.loads(loads(sys.stdin)) + yield load_pickle(read_with_length(sys.stdin)) except EOFError: return -def do_pipeline(): - f = load_function() - for obj in f(read_input()): - output(PickleSerializer.dumps(obj)) - - -def do_shuffle_map_step(): - hashFunc = load_function() - while True: - try: - pickled = loads(sys.stdin) - except EOFError: - return - key = cPickle.loads(pickled)[0] - output(str(hashFunc(key))) - output(pickled) - - def main(): num_broadcast_variables = int(sys.stdin.readline().strip()) for _ in range(num_broadcast_variables): uuid = sys.stdin.read(36) - value = loads(sys.stdin) - _broadcastRegistry[uuid] = Broadcast(uuid, cPickle.loads(value)) - command = sys.stdin.readline().strip() - if command == "pipeline": - do_pipeline() - elif command == "shuffle_map_step": - do_shuffle_map_step() + value = read_with_length(sys.stdin) + _broadcastRegistry[uuid] = Broadcast(uuid, load_pickle(value)) + func = load_obj() + bypassSerializer = load_obj() + if bypassSerializer: + dumps = lambda x: x else: - raise Exception("Unsupported command %s" % command) + dumps = dump_pickle + for obj in func(read_input()): + write_with_length(dumps(obj), old_stdout) if __name__ == '__main__': From bff6a46359131a8f9bc38b93149b22baa7c711cd Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 25 Aug 2012 18:00:25 -0700 Subject: [PATCH 13/85] Add pipe(), saveAsTextFile(), sc.union() to Python API. --- .../scala/spark/api/python/PythonRDD.scala | 10 +++++--- pyspark/pyspark/context.py | 14 ++++++----- pyspark/pyspark/rdd.py | 25 +++++++++++++++++-- 3 files changed, 38 insertions(+), 11 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index b9091fd436..4d3bdb3963 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -9,6 +9,7 @@ import spark._ import api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} import broadcast.Broadcast import scala.collection +import java.nio.charset.Charset trait PythonRDDBase { def compute[T](split: Split, envVars: Map[String, String], @@ -238,9 +239,12 @@ private object Pickle { val MARK : Byte = '(' val APPENDS : Byte = 'e' } -class ExtractValue extends spark.api.java.function.Function[(Array[Byte], + +private class ExtractValue extends spark.api.java.function.Function[(Array[Byte], Array[Byte]), Array[Byte]] { - override def call(pair: (Array[Byte], Array[Byte])) : Array[Byte] = pair._2 - +} + +private class BytesToString extends spark.api.java.function.Function[Array[Byte], String] { + override def call(arr: Array[Byte]) : String = new String(arr, "UTF-8") } diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index b8490019e3..04932c93f2 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -7,6 +7,8 @@ from pyspark.java_gateway import launch_gateway from pyspark.serializers import dump_pickle, write_with_length from pyspark.rdd import RDD +from py4j.java_collections import ListConverter + class SparkContext(object): @@ -39,12 +41,6 @@ class SparkContext(object): self._jsc = None def parallelize(self, c, numSlices=None): - """ - >>> sc = SparkContext("local", "test") - >>> rdd = sc.parallelize([(1, 2), (3, 4)]) - >>> rdd.collect() - [(1, 2), (3, 4)] - """ numSlices = numSlices or self.defaultParallelism # Calling the Java parallelize() method with an ArrayList is too slow, # because it sends O(n) Py4J commands. As an alternative, serialized @@ -62,6 +58,12 @@ class SparkContext(object): jrdd = self._jsc.textFile(name, minSplits) return RDD(jrdd, self) + def union(self, rdds): + first = rdds[0]._jrdd + rest = [x._jrdd for x in rdds[1:]] + rest = ListConverter().convert(rest, self.gateway._gateway_client) + return RDD(self._jsc.union(first, rest), self) + def broadcast(self, value): jbroadcast = self._jsc.broadcast(bytearray(dump_pickle(value))) return Broadcast(jbroadcast.uuid().toString(), value, jbroadcast, diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 21e822ba9f..8477f6dd02 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,6 +1,9 @@ from base64 import standard_b64encode as b64enc from collections import Counter from itertools import chain, ifilter, imap +import shlex +from subprocess import Popen, PIPE +from threading import Thread from pyspark import cloudpickle from pyspark.serializers import dump_pickle, load_pickle @@ -118,7 +121,20 @@ class RDD(object): """ return self.map(lambda x: (f(x), x)).groupByKey(numSplits) - # TODO: pipe + def pipe(self, command, env={}): + """ + >>> sc.parallelize([1, 2, 3]).pipe('cat').collect() + ['1', '2', '3'] + """ + def func(iterator): + pipe = Popen(shlex.split(command), env=env, stdin=PIPE, stdout=PIPE) + def pipe_objs(out): + for obj in iterator: + out.write(str(obj).rstrip('\n') + '\n') + out.close() + Thread(target=pipe_objs, args=[pipe.stdin]).start() + return (x.rstrip('\n') for x in pipe.stdout) + return self.mapPartitions(func) def foreach(self, f): """ @@ -206,7 +222,12 @@ class RDD(object): """ return load_pickle(bytes(self.ctx.asPickle(self._jrdd.first()))) - # TODO: saveAsTextFile + def saveAsTextFile(self, path): + def func(iterator): + return (str(x).encode("utf-8") for x in iterator) + keyed = PipelinedRDD(self, func) + keyed._bypass_serializer = True + keyed._jrdd.map(self.ctx.jvm.BytesToString()).saveAsTextFile(path) # Pair functions From 414367850982c4f8fc5e63cc94caa422eb736db5 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 27 Aug 2012 00:13:19 -0700 Subject: [PATCH 14/85] Fix minor bugs in Python API examples. --- pyspark/pyspark/examples/pi.py | 2 +- pyspark/pyspark/examples/tc.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pyspark/pyspark/examples/pi.py b/pyspark/pyspark/examples/pi.py index fe63d2c952..348bbc5dce 100644 --- a/pyspark/pyspark/examples/pi.py +++ b/pyspark/pyspark/examples/pi.py @@ -9,7 +9,7 @@ if __name__ == "__main__": print >> sys.stderr, \ "Usage: PythonPi []" exit(-1) - sc = SparkContext(sys.argv[1], "PythonKMeans") + sc = SparkContext(sys.argv[1], "PythonPi") slices = int(sys.argv[2]) if len(sys.argv) > 2 else 2 n = 100000 * slices def f(_): diff --git a/pyspark/pyspark/examples/tc.py b/pyspark/pyspark/examples/tc.py index 2796fdc6ad..9630e72b47 100644 --- a/pyspark/pyspark/examples/tc.py +++ b/pyspark/pyspark/examples/tc.py @@ -22,9 +22,9 @@ if __name__ == "__main__": print >> sys.stderr, \ "Usage: PythonTC []" exit(-1) - sc = SparkContext(sys.argv[1], "PythonKMeans") + sc = SparkContext(sys.argv[1], "PythonTC") slices = sys.argv[2] if len(sys.argv) > 2 else 2 - tc = sc.parallelizePairs(generateGraph(), slices).cache() + tc = sc.parallelize(generateGraph(), slices).cache() # Linear transitive closure: each round grows paths by one edge, # by joining the graph's edges with the already-discovered paths. @@ -32,7 +32,7 @@ if __name__ == "__main__": # the graph to obtain the path (x, z). # Because join() joins on keys, the edges are stored in reversed order. - edges = tc.mapPairs(lambda (x, y): (y, x)) + edges = tc.map(lambda (x, y): (y, x)) oldCount = 0L nextCount = tc.count() @@ -40,7 +40,7 @@ if __name__ == "__main__": oldCount = nextCount # Perform the join, obtaining an RDD of (y, (z, x)) pairs, # then project the result to obtain the new (x, z) paths. - new_edges = tc.join(edges).mapPairs(lambda (_, (a, b)): (b, a)) + new_edges = tc.join(edges).map(lambda (_, (a, b)): (b, a)) tc = tc.union(new_edges).distinct().cache() nextCount = tc.count() if nextCount == oldCount: From 9abdfa663360252d2edb346e6b3df4ff94ce78d7 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 17 Sep 2012 00:08:50 -0700 Subject: [PATCH 15/85] Fix Python 2.6 compatibility in Python API. --- pyspark/pyspark/rdd.py | 17 +++++++++++------ python/tc.py | 22 ---------------------- 2 files changed, 11 insertions(+), 28 deletions(-) delete mode 100644 python/tc.py diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 8477f6dd02..e2137fe06c 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,5 +1,5 @@ from base64 import standard_b64encode as b64enc -from collections import Counter +from collections import defaultdict from itertools import chain, ifilter, imap import shlex from subprocess import Popen, PIPE @@ -198,13 +198,18 @@ class RDD(object): def countByValue(self): """ - >>> sc.parallelize([1, 2, 1, 2, 2]).countByValue().most_common() - [(2, 3), (1, 2)] + >>> sorted(sc.parallelize([1, 2, 1, 2, 2], 2).countByValue().items()) + [(1, 2), (2, 3)] """ def countPartition(iterator): - yield Counter(iterator) + counts = defaultdict(int) + for obj in iterator: + counts[obj] += 1 + yield counts def mergeMaps(m1, m2): - return m1 + m2 + for (k, v) in m2.iteritems(): + m1[k] += v + return m1 return self.mapPartitions(countPartition).reduce(mergeMaps) def take(self, num): @@ -271,7 +276,7 @@ class RDD(object): def countByKey(self): """ >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) - >>> rdd.countByKey().most_common() + >>> sorted(rdd.countByKey().items()) [('a', 2), ('b', 1)] """ return self.map(lambda x: x[0]).countByValue() diff --git a/python/tc.py b/python/tc.py deleted file mode 100644 index 5dcc4317e0..0000000000 --- a/python/tc.py +++ /dev/null @@ -1,22 +0,0 @@ -from rdd import SparkContext - -sc = SparkContext("local", "PythonWordCount") -e = [(1, 2), (2, 3), (4, 1)] - -tc = sc.parallelizePairs(e) - -edges = tc.mapPairs(lambda (x, y): (y, x)) - -oldCount = 0 -nextCount = tc.count() - -def project(x): - return (x[1][1], x[1][0]) - -while nextCount != oldCount: - oldCount = nextCount - tc = tc.union(tc.join(edges).mapPairs(project)).distinct() - nextCount = tc.count() - -print "TC has %i edges" % tc.count() -print tc.collect() From 52989c8a2c8c10d7f5610c033f6782e58fd3abc2 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 19 Oct 2012 10:24:49 -0700 Subject: [PATCH 16/85] Update Python API for v0.6.0 compatibility. --- .../scala/spark/api/python/PythonRDD.scala | 18 +++++++++++------- .../main/scala/spark/broadcast/Broadcast.scala | 2 +- pyspark/pyspark/broadcast.py | 18 +++++++++--------- pyspark/pyspark/context.py | 2 +- pyspark/pyspark/java_gateway.py | 3 ++- pyspark/pyspark/serializers.py | 18 ++++++++++++++---- pyspark/pyspark/worker.py | 8 ++++---- 7 files changed, 42 insertions(+), 27 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 4d3bdb3963..528885fe5c 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -5,11 +5,15 @@ import java.io._ import scala.collection.Map import scala.collection.JavaConversions._ import scala.io.Source -import spark._ -import api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} -import broadcast.Broadcast -import scala.collection -import java.nio.charset.Charset + +import spark.api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} +import spark.broadcast.Broadcast +import spark.SparkEnv +import spark.Split +import spark.RDD +import spark.OneToOneDependency +import spark.rdd.PipedRDD + trait PythonRDDBase { def compute[T](split: Split, envVars: Map[String, String], @@ -43,9 +47,9 @@ trait PythonRDDBase { SparkEnv.set(env) val out = new PrintWriter(proc.getOutputStream) val dOut = new DataOutputStream(proc.getOutputStream) - out.println(broadcastVars.length) + dOut.writeInt(broadcastVars.length) for (broadcast <- broadcastVars) { - out.print(broadcast.uuid.toString) + dOut.writeLong(broadcast.id) dOut.writeInt(broadcast.value.length) dOut.write(broadcast.value) dOut.flush() diff --git a/core/src/main/scala/spark/broadcast/Broadcast.scala b/core/src/main/scala/spark/broadcast/Broadcast.scala index 6055bfd045..2ffe7f741d 100644 --- a/core/src/main/scala/spark/broadcast/Broadcast.scala +++ b/core/src/main/scala/spark/broadcast/Broadcast.scala @@ -5,7 +5,7 @@ import java.util.concurrent.atomic.AtomicLong import spark._ -abstract class Broadcast[T](id: Long) extends Serializable { +abstract class Broadcast[T](private[spark] val id: Long) extends Serializable { def value: T // We cannot have an abstract readObject here due to some weird issues with diff --git a/pyspark/pyspark/broadcast.py b/pyspark/pyspark/broadcast.py index 1ea17d59af..4cff02b36d 100644 --- a/pyspark/pyspark/broadcast.py +++ b/pyspark/pyspark/broadcast.py @@ -6,7 +6,7 @@ [1, 2, 3, 4, 5] >>> from pyspark.broadcast import _broadcastRegistry ->>> _broadcastRegistry[b.uuid] = b +>>> _broadcastRegistry[b.bid] = b >>> from cPickle import dumps, loads >>> loads(dumps(b)).value [1, 2, 3, 4, 5] @@ -14,27 +14,27 @@ >>> sc.parallelize([0, 0]).flatMap(lambda x: b.value).collect() [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] """ -# Holds broadcasted data received from Java, keyed by UUID. +# Holds broadcasted data received from Java, keyed by its id. _broadcastRegistry = {} -def _from_uuid(uuid): +def _from_id(bid): from pyspark.broadcast import _broadcastRegistry - if uuid not in _broadcastRegistry: - raise Exception("Broadcast variable '%s' not loaded!" % uuid) - return _broadcastRegistry[uuid] + if bid not in _broadcastRegistry: + raise Exception("Broadcast variable '%s' not loaded!" % bid) + return _broadcastRegistry[bid] class Broadcast(object): - def __init__(self, uuid, value, java_broadcast=None, pickle_registry=None): + def __init__(self, bid, value, java_broadcast=None, pickle_registry=None): self.value = value - self.uuid = uuid + self.bid = bid self._jbroadcast = java_broadcast self._pickle_registry = pickle_registry def __reduce__(self): self._pickle_registry.add(self) - return (_from_uuid, (self.uuid, )) + return (_from_id, (self.bid, )) def _test(): diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 04932c93f2..3f4db26644 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -66,5 +66,5 @@ class SparkContext(object): def broadcast(self, value): jbroadcast = self._jsc.broadcast(bytearray(dump_pickle(value))) - return Broadcast(jbroadcast.uuid().toString(), value, jbroadcast, + return Broadcast(jbroadcast.id(), value, jbroadcast, self._pickled_broadcast_vars) diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py index bcb405ba72..3726bcbf17 100644 --- a/pyspark/pyspark/java_gateway.py +++ b/pyspark/pyspark/java_gateway.py @@ -7,7 +7,8 @@ SPARK_HOME = os.environ["SPARK_HOME"] assembly_jar = glob.glob(os.path.join(SPARK_HOME, "core/target") + \ - "/spark-core-assembly-*-SNAPSHOT.jar")[0] + "/spark-core-assembly-*.jar")[0] + # TODO: what if multiple assembly jars are found? def launch_gateway(): diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index faa1e683c7..21ef8b106c 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -9,16 +9,26 @@ def dump_pickle(obj): load_pickle = cPickle.loads +def read_long(stream): + length = stream.read(8) + if length == "": + raise EOFError + return struct.unpack("!q", length)[0] + + +def read_int(stream): + length = stream.read(4) + if length == "": + raise EOFError + return struct.unpack("!i", length)[0] + def write_with_length(obj, stream): stream.write(struct.pack("!i", len(obj))) stream.write(obj) def read_with_length(stream): - length = stream.read(4) - if length == "": - raise EOFError - length = struct.unpack("!i", length)[0] + length = read_int(stream) obj = stream.read(length) if obj == "": raise EOFError diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index a9ed71892f..62824a1c9b 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -8,7 +8,7 @@ from base64 import standard_b64decode from pyspark.broadcast import Broadcast, _broadcastRegistry from pyspark.cloudpickle import CloudPickler from pyspark.serializers import write_with_length, read_with_length, \ - dump_pickle, load_pickle + read_long, read_int, dump_pickle, load_pickle # Redirect stdout to stderr so that users must return values from functions. @@ -29,11 +29,11 @@ def read_input(): def main(): - num_broadcast_variables = int(sys.stdin.readline().strip()) + num_broadcast_variables = read_int(sys.stdin) for _ in range(num_broadcast_variables): - uuid = sys.stdin.read(36) + bid = read_long(sys.stdin) value = read_with_length(sys.stdin) - _broadcastRegistry[uuid] = Broadcast(uuid, load_pickle(value)) + _broadcastRegistry[bid] = Broadcast(bid, load_pickle(value)) func = load_obj() bypassSerializer = load_obj() if bypassSerializer: From c23bf1aff4b9a1faf9d32c7b64acad2213f9515c Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 20 Oct 2012 00:16:41 +0000 Subject: [PATCH 17/85] Add PySpark README and run scripts. --- core/src/main/scala/spark/SparkContext.scala | 2 +- pyspark/README | 58 ++++++++++++++++++++ pyspark/pyspark-shell | 3 + pyspark/pyspark/context.py | 5 +- pyspark/pyspark/examples/wordcount.py | 17 ++++++ pyspark/pyspark/shell.py | 21 +++++++ pyspark/run-pyspark | 23 ++++++++ 7 files changed, 125 insertions(+), 4 deletions(-) create mode 100644 pyspark/README create mode 100755 pyspark/pyspark-shell create mode 100644 pyspark/pyspark/examples/wordcount.py create mode 100644 pyspark/pyspark/shell.py create mode 100755 pyspark/run-pyspark diff --git a/core/src/main/scala/spark/SparkContext.scala b/core/src/main/scala/spark/SparkContext.scala index becf737597..acb38ae33d 100644 --- a/core/src/main/scala/spark/SparkContext.scala +++ b/core/src/main/scala/spark/SparkContext.scala @@ -113,7 +113,7 @@ class SparkContext( // Environment variables to pass to our executors private[spark] val executorEnvs = HashMap[String, String]() for (key <- Seq("SPARK_MEM", "SPARK_CLASSPATH", "SPARK_LIBRARY_PATH", "SPARK_JAVA_OPTS", - "SPARK_TESTING")) { + "SPARK_TESTING", "PYTHONPATH")) { val value = System.getenv(key) if (value != null) { executorEnvs(key) = value diff --git a/pyspark/README b/pyspark/README new file mode 100644 index 0000000000..63a1def141 --- /dev/null +++ b/pyspark/README @@ -0,0 +1,58 @@ +# PySpark + +PySpark is a Python API for Spark. + +PySpark jobs are writen in Python and executed using a standard Python +interpreter; this supports modules that use Python C extensions. The +API is based on the Spark Scala API and uses regular Python functions +and lambdas to support user-defined functions. PySpark supports +interactive use through a standard Python interpreter; it can +automatically serialize closures and ship them to worker processes. + +PySpark is built on top of the Spark Java API. Data is uniformly +represented as serialized Python objects and stored in Spark Java +processes, which communicate with PySpark worker processes over pipes. + +## Features + +PySpark supports most of the Spark API, including broadcast variables. +RDDs are dynamically typed and can hold any Python object. + +PySpark does not support: + +- Special functions on RDDs of doubles +- Accumulators + +## Examples and Documentation + +The PySpark source contains docstrings and doctests that document its +API. The public classes are in `context.py` and `rdd.py`. + +The `pyspark/pyspark/examples` directory contains a few complete +examples. + +## Installing PySpark + +PySpark requires a development version of Py4J, a Python library for +interacting with Java processes. It can be installed from +https://github.com/bartdag/py4j; make sure to install a version that +contains at least the commits through 3dbf380d3d. + +PySpark uses the `PYTHONPATH` environment variable to search for Python +classes; Py4J should be on this path, along with any libraries used by +PySpark programs. `PYTHONPATH` will be automatically shipped to worker +machines, but the files that it points to must be present on each +machine. + +PySpark requires the Spark assembly JAR, which can be created by running +`sbt/sbt assembly` in the Spark directory. + +Additionally, `SPARK_HOME` should be set to the location of the Spark +package. + +## Running PySpark + +The easiest way to run PySpark is to use the `run-pyspark` and +`pyspark-shell` scripts, which are included in the `pyspark` directory. +These scripts automatically load the `spark-conf.sh` file, set +`SPARK_HOME`, and add the `pyspark` package to the `PYTHONPATH`. diff --git a/pyspark/pyspark-shell b/pyspark/pyspark-shell new file mode 100755 index 0000000000..4ed3e6010c --- /dev/null +++ b/pyspark/pyspark-shell @@ -0,0 +1,3 @@ +#!/bin/sh +FWDIR="`dirname $0`" +exec $FWDIR/run-pyspark $FWDIR/pyspark/shell.py "$@" diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 3f4db26644..50d57e5317 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -18,14 +18,13 @@ class SparkContext(object): asPickle = jvm.spark.api.python.PythonRDD.asPickle arrayAsPickle = jvm.spark.api.python.PythonRDD.arrayAsPickle - def __init__(self, master, name, defaultParallelism=None, - pythonExec='python'): + def __init__(self, master, name, defaultParallelism=None): self.master = master self.name = name self._jsc = self.jvm.JavaSparkContext(master, name) self.defaultParallelism = \ defaultParallelism or self._jsc.sc().defaultParallelism() - self.pythonExec = pythonExec + self.pythonExec = os.environ.get("PYSPARK_PYTHON_EXEC", 'python') # Broadcast's __reduce__ method stores Broadcast instances here. # This allows other code to determine which Broadcast instances have # been pickled, so it can determine which Java broadcast objects to diff --git a/pyspark/pyspark/examples/wordcount.py b/pyspark/pyspark/examples/wordcount.py new file mode 100644 index 0000000000..8365c070e8 --- /dev/null +++ b/pyspark/pyspark/examples/wordcount.py @@ -0,0 +1,17 @@ +import sys +from operator import add +from pyspark.context import SparkContext + +if __name__ == "__main__": + if len(sys.argv) < 3: + print >> sys.stderr, \ + "Usage: PythonWordCount " + exit(-1) + sc = SparkContext(sys.argv[1], "PythonWordCount") + lines = sc.textFile(sys.argv[2], 1) + counts = lines.flatMap(lambda x: x.split(' ')) \ + .map(lambda x: (x, 1)) \ + .reduceByKey(add) + output = counts.collect() + for (word, count) in output: + print "%s : %i" % (word, count) diff --git a/pyspark/pyspark/shell.py b/pyspark/pyspark/shell.py new file mode 100644 index 0000000000..7ef30894cb --- /dev/null +++ b/pyspark/pyspark/shell.py @@ -0,0 +1,21 @@ +""" +An interactive shell. +""" +import code +import sys + +from pyspark.context import SparkContext + + +def main(master='local'): + sc = SparkContext(master, 'PySparkShell') + print "Spark context available as sc." + code.interact(local={'sc': sc}) + + +if __name__ == '__main__': + if len(sys.argv) > 1: + master = sys.argv[1] + else: + master = 'local' + main(master) diff --git a/pyspark/run-pyspark b/pyspark/run-pyspark new file mode 100755 index 0000000000..9c5e027962 --- /dev/null +++ b/pyspark/run-pyspark @@ -0,0 +1,23 @@ +#!/bin/bash + +# Figure out where the Scala framework is installed +FWDIR="$(cd `dirname $0`; cd ../; pwd)" + +# Export this as SPARK_HOME +export SPARK_HOME="$FWDIR" + +# Load environment variables from conf/spark-env.sh, if it exists +if [ -e $FWDIR/conf/spark-env.sh ] ; then + . $FWDIR/conf/spark-env.sh +fi + +# Figure out which Python executable to use +if [ -z "$PYSPARK_PYTHON" ] ; then + PYSPARK_PYTHON="python" +fi +export PYSPARK_PYTHON + +# Add the PySpark classes to the Python path: +export PYTHONPATH=$SPARK_HOME/pyspark/:$PYTHONPATH + +exec "$PYSPARK_PYTHON" "$@" From d4f2e5b0ef38db9d42bb0d5fbbbe6103ce047efe Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 22 Oct 2012 10:28:59 -0700 Subject: [PATCH 18/85] Remove PYTHONPATH from SparkContext's executorEnvs. It makes more sense to pass it in the dictionary of environment variables that is used to construct PythonRDD. --- core/src/main/scala/spark/SparkContext.scala | 2 +- .../main/scala/spark/api/python/PythonRDD.scala | 15 +++++++-------- pyspark/pyspark/rdd.py | 8 ++++++-- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/core/src/main/scala/spark/SparkContext.scala b/core/src/main/scala/spark/SparkContext.scala index acb38ae33d..becf737597 100644 --- a/core/src/main/scala/spark/SparkContext.scala +++ b/core/src/main/scala/spark/SparkContext.scala @@ -113,7 +113,7 @@ class SparkContext( // Environment variables to pass to our executors private[spark] val executorEnvs = HashMap[String, String]() for (key <- Seq("SPARK_MEM", "SPARK_CLASSPATH", "SPARK_LIBRARY_PATH", "SPARK_JAVA_OPTS", - "SPARK_TESTING", "PYTHONPATH")) { + "SPARK_TESTING")) { val value = System.getenv(key) if (value != null) { executorEnvs(key) = value diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 528885fe5c..a593e53efd 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -131,18 +131,17 @@ trait PythonRDDBase { } class PythonRDD[T: ClassManifest]( - parent: RDD[T], command: Seq[String], envVars: Map[String, String], + parent: RDD[T], command: Seq[String], envVars: java.util.Map[String, String], preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) extends RDD[Array[Byte]](parent.context) with PythonRDDBase { - def this(parent: RDD[T], command: Seq[String], preservePartitoning: Boolean, - pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = - this(parent, command, Map(), preservePartitoning, pythonExec, broadcastVars) - // Similar to Runtime.exec(), if we are given a single string, split it into words // using a standard StringTokenizer (i.e. by spaces) - def this(parent: RDD[T], command: String, preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = - this(parent, PipedRDD.tokenize(command), preservePartitoning, pythonExec, broadcastVars) + def this(parent: RDD[T], command: String, envVars: java.util.Map[String, String], + preservePartitoning: Boolean, pythonExec: String, + broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, PipedRDD.tokenize(command), envVars, preservePartitoning, pythonExec, + broadcastVars) override def splits = parent.splits @@ -151,7 +150,7 @@ class PythonRDD[T: ClassManifest]( override val partitioner = if (preservePartitoning) parent.partitioner else None override def compute(split: Split): Iterator[Array[Byte]] = - compute(split, envVars, command, parent, pythonExec, broadcastVars) + compute(split, envVars.toMap, command, parent, pythonExec, broadcastVars) val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index e2137fe06c..e4878c08ba 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,6 +1,7 @@ from base64 import standard_b64encode as b64enc from collections import defaultdict from itertools import chain, ifilter, imap +import os import shlex from subprocess import Popen, PIPE from threading import Thread @@ -10,7 +11,7 @@ from pyspark.serializers import dump_pickle, load_pickle from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup -from py4j.java_collections import ListConverter +from py4j.java_collections import ListConverter, MapConverter class RDD(object): @@ -447,8 +448,11 @@ class PipelinedRDD(RDD): self.ctx.gateway._gateway_client) self.ctx._pickled_broadcast_vars.clear() class_manifest = self._prev_jrdd.classManifest() + env = MapConverter().convert( + {'PYTHONPATH' : os.environ.get("PYTHONPATH", "")}, + self.ctx.gateway._gateway_client) python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), - pipe_command, self.preservesPartitioning, self.ctx.pythonExec, + pipe_command, env, self.preservesPartitioning, self.ctx.pythonExec, broadcast_vars, class_manifest) self._jrdd_val = python_rdd.asJavaRDD() return self._jrdd_val From 7859879aaa1860ff6b383e32a18fd9a410a97416 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sun, 28 Oct 2012 16:46:31 -0700 Subject: [PATCH 19/85] Bump required Py4J version and add test for large broadcast variables. --- pyspark/README | 2 +- pyspark/pyspark/broadcast.py | 2 ++ pyspark/requirements.txt | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/pyspark/README b/pyspark/README index 63a1def141..55490e1a83 100644 --- a/pyspark/README +++ b/pyspark/README @@ -36,7 +36,7 @@ examples. PySpark requires a development version of Py4J, a Python library for interacting with Java processes. It can be installed from https://github.com/bartdag/py4j; make sure to install a version that -contains at least the commits through 3dbf380d3d. +contains at least the commits through b7924aabe9. PySpark uses the `PYTHONPATH` environment variable to search for Python classes; Py4J should be on this path, along with any libraries used by diff --git a/pyspark/pyspark/broadcast.py b/pyspark/pyspark/broadcast.py index 4cff02b36d..93876fa738 100644 --- a/pyspark/pyspark/broadcast.py +++ b/pyspark/pyspark/broadcast.py @@ -13,6 +13,8 @@ >>> sc.parallelize([0, 0]).flatMap(lambda x: b.value).collect() [1, 2, 3, 4, 5, 1, 2, 3, 4, 5] + +>>> large_broadcast = sc.broadcast(list(range(10000))) """ # Holds broadcasted data received from Java, keyed by its id. _broadcastRegistry = {} diff --git a/pyspark/requirements.txt b/pyspark/requirements.txt index 71e2bc2b89..48fa2ab105 100644 --- a/pyspark/requirements.txt +++ b/pyspark/requirements.txt @@ -3,4 +3,4 @@ # package is not at the root of the git repository. It may be possible to # install Py4J from git once https://github.com/pypa/pip/pull/526 is merged. -# git+git://github.com/bartdag/py4j.git@3dbf380d3d2cdeb9aab394454ea74d80c4aba1ea +# git+git://github.com/bartdag/py4j.git@b7924aabe9c5e63f0a4d8bbd17019534c7ec014e From 2ccf3b665280bf5b0919e3801d028126cb070dbd Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sun, 28 Oct 2012 22:30:28 -0700 Subject: [PATCH 20/85] Fix PySpark hash partitioning bug. A Java array's hashCode is based on its object identify, not its elements, so this was causing serialized keys to be hashed incorrectly. This commit adds a PySpark-specific workaround and adds more tests. --- .../spark/api/python/PythonPartitioner.scala | 41 +++++++++++++++++++ .../scala/spark/api/python/PythonRDD.scala | 10 ++--- pyspark/pyspark/rdd.py | 12 ++++-- 3 files changed, 54 insertions(+), 9 deletions(-) create mode 100644 core/src/main/scala/spark/api/python/PythonPartitioner.scala diff --git a/core/src/main/scala/spark/api/python/PythonPartitioner.scala b/core/src/main/scala/spark/api/python/PythonPartitioner.scala new file mode 100644 index 0000000000..ef9f808fb2 --- /dev/null +++ b/core/src/main/scala/spark/api/python/PythonPartitioner.scala @@ -0,0 +1,41 @@ +package spark.api.python + +import spark.Partitioner + +import java.util.Arrays + +/** + * A [[spark.Partitioner]] that performs handling of byte arrays, for use by the Python API. + */ +class PythonPartitioner(override val numPartitions: Int) extends Partitioner { + + override def getPartition(key: Any): Int = { + if (key == null) { + return 0 + } + else { + val hashCode = { + if (key.isInstanceOf[Array[Byte]]) { + System.err.println("Dumping a byte array!" + Arrays.hashCode(key.asInstanceOf[Array[Byte]]) + ) + Arrays.hashCode(key.asInstanceOf[Array[Byte]]) + } + else + key.hashCode() + } + val mod = hashCode % numPartitions + if (mod < 0) { + mod + numPartitions + } else { + mod // Guard against negative hash codes + } + } + } + + override def equals(other: Any): Boolean = other match { + case h: PythonPartitioner => + h.numPartitions == numPartitions + case _ => + false + } +} diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index a593e53efd..50094d6b0f 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -179,14 +179,12 @@ object PythonRDD { val dOut = new DataOutputStream(baos); if (elem.isInstanceOf[Array[Byte]]) { elem.asInstanceOf[Array[Byte]] - } else if (elem.isInstanceOf[scala.Tuple2[_, _]]) { - val t = elem.asInstanceOf[scala.Tuple2[_, _]] - val t1 = t._1.asInstanceOf[Array[Byte]] - val t2 = t._2.asInstanceOf[Array[Byte]] + } else if (elem.isInstanceOf[scala.Tuple2[Array[Byte], Array[Byte]]]) { + val t = elem.asInstanceOf[scala.Tuple2[Array[Byte], Array[Byte]]] dOut.writeByte(Pickle.PROTO) dOut.writeByte(Pickle.TWO) - dOut.write(PythonRDD.stripPickle(t1)) - dOut.write(PythonRDD.stripPickle(t2)) + dOut.write(PythonRDD.stripPickle(t._1)) + dOut.write(PythonRDD.stripPickle(t._2)) dOut.writeByte(Pickle.TUPLE2) dOut.writeByte(Pickle.STOP) baos.toByteArray() diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index e4878c08ba..85a24c6854 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -310,6 +310,12 @@ class RDD(object): return python_right_outer_join(self, other, numSplits) def partitionBy(self, numSplits, hashFunc=hash): + """ + >>> pairs = sc.parallelize([1, 2, 3, 4, 2, 4, 1]).map(lambda x: (x, x)) + >>> sets = pairs.partitionBy(2).glom().collect() + >>> set(sets[0]).intersection(set(sets[1])) + set([]) + """ if numSplits is None: numSplits = self.ctx.defaultParallelism def add_shuffle_key(iterator): @@ -319,7 +325,7 @@ class RDD(object): keyed = PipelinedRDD(self, add_shuffle_key) keyed._bypass_serializer = True pairRDD = self.ctx.jvm.PairwiseRDD(keyed._jrdd.rdd()).asJavaPairRDD() - partitioner = self.ctx.jvm.spark.HashPartitioner(numSplits) + partitioner = self.ctx.jvm.spark.api.python.PythonPartitioner(numSplits) jrdd = pairRDD.partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) return RDD(jrdd, self.ctx) @@ -391,7 +397,7 @@ class RDD(object): """ >>> x = sc.parallelize([("a", 1), ("b", 4)]) >>> y = sc.parallelize([("a", 2)]) - >>> x.cogroup(y).collect() + >>> sorted(x.cogroup(y).collect()) [('a', ([1], [2])), ('b', ([4], []))] """ return python_cogroup(self, other, numSplits) @@ -462,7 +468,7 @@ def _test(): import doctest from pyspark.context import SparkContext globs = globals().copy() - globs['sc'] = SparkContext('local', 'PythonTest') + globs['sc'] = SparkContext('local[4]', 'PythonTest') doctest.testmod(globs=globs) globs['sc'].stop() From ccd075cf960df6c6c449b709515cdd81499a52be Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 24 Dec 2012 15:01:13 -0800 Subject: [PATCH 21/85] Reduce object overhead in Pyspark shuffle and collect --- pyspark/pyspark/rdd.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 85a24c6854..708ea6eb55 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -145,8 +145,10 @@ class RDD(object): self.map(f).collect() # Force evaluation def collect(self): - pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().collect()) - return load_pickle(bytes(pickle)) + def asList(iterator): + yield list(iterator) + pickles = self.mapPartitions(asList)._jrdd.rdd().collect() + return list(chain.from_iterable(load_pickle(bytes(p)) for p in pickles)) def reduce(self, f): """ @@ -319,16 +321,23 @@ class RDD(object): if numSplits is None: numSplits = self.ctx.defaultParallelism def add_shuffle_key(iterator): + buckets = defaultdict(list) for (k, v) in iterator: - yield str(hashFunc(k)) - yield dump_pickle((k, v)) + buckets[hashFunc(k) % numSplits].append((k, v)) + for (split, items) in buckets.iteritems(): + yield str(split) + yield dump_pickle(items) keyed = PipelinedRDD(self, add_shuffle_key) keyed._bypass_serializer = True pairRDD = self.ctx.jvm.PairwiseRDD(keyed._jrdd.rdd()).asJavaPairRDD() partitioner = self.ctx.jvm.spark.api.python.PythonPartitioner(numSplits) + # Transferring O(n) objects to Java is too expensive. Instead, we'll + # form the hash buckets in Python, transferring O(numSplits) objects + # to Java. Each object is a (splitNumber, [objects]) pair. jrdd = pairRDD.partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) - return RDD(jrdd, self.ctx) + # Flatten the resulting RDD: + return RDD(jrdd, self.ctx).flatMap(lambda items: items) def combineByKey(self, createCombiner, mergeValue, mergeCombiners, numSplits=None): From 4608902fb87af64a15b97ab21fe6382cd6e5a644 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 24 Dec 2012 17:20:10 -0800 Subject: [PATCH 22/85] Use filesystem to collect RDDs in PySpark. Passing large volumes of data through Py4J seems to be slow. It appears to be faster to write the data to the local filesystem and read it back from Python. --- .../scala/spark/api/python/PythonRDD.scala | 66 +++++++------------ pyspark/pyspark/context.py | 9 ++- pyspark/pyspark/rdd.py | 34 ++++++++-- pyspark/pyspark/serializers.py | 8 +++ pyspark/pyspark/worker.py | 12 +--- 5 files changed, 66 insertions(+), 63 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 50094d6b0f..4f870e837a 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -1,6 +1,7 @@ package spark.api.python import java.io._ +import java.util.{List => JList} import scala.collection.Map import scala.collection.JavaConversions._ @@ -59,36 +60,7 @@ trait PythonRDDBase { } out.flush() for (elem <- parent.iterator(split)) { - if (elem.isInstanceOf[Array[Byte]]) { - val arr = elem.asInstanceOf[Array[Byte]] - dOut.writeInt(arr.length) - dOut.write(arr) - } else if (elem.isInstanceOf[scala.Tuple2[_, _]]) { - val t = elem.asInstanceOf[scala.Tuple2[_, _]] - val t1 = t._1.asInstanceOf[Array[Byte]] - val t2 = t._2.asInstanceOf[Array[Byte]] - val length = t1.length + t2.length - 3 - 3 + 4 // stripPickle() removes 3 bytes - dOut.writeInt(length) - dOut.writeByte(Pickle.PROTO) - dOut.writeByte(Pickle.TWO) - dOut.write(PythonRDD.stripPickle(t1)) - dOut.write(PythonRDD.stripPickle(t2)) - dOut.writeByte(Pickle.TUPLE2) - dOut.writeByte(Pickle.STOP) - } else if (elem.isInstanceOf[String]) { - // For uniformity, strings are wrapped into Pickles. - val s = elem.asInstanceOf[String].getBytes("UTF-8") - val length = 2 + 1 + 4 + s.length + 1 - dOut.writeInt(length) - dOut.writeByte(Pickle.PROTO) - dOut.writeByte(Pickle.TWO) - dOut.writeByte(Pickle.BINUNICODE) - dOut.writeInt(Integer.reverseBytes(s.length)) - dOut.write(s) - dOut.writeByte(Pickle.STOP) - } else { - throw new Exception("Unexpected RDD type") - } + PythonRDD.writeAsPickle(elem, dOut) } dOut.flush() out.flush() @@ -174,36 +146,45 @@ object PythonRDD { arr.slice(2, arr.length - 1) } - def asPickle(elem: Any) : Array[Byte] = { - val baos = new ByteArrayOutputStream(); - val dOut = new DataOutputStream(baos); + /** + * Write strings, pickled Python objects, or pairs of pickled objects to a data output stream. + * The data format is a 32-bit integer representing the pickled object's length (in bytes), + * followed by the pickled data. + * @param elem the object to write + * @param dOut a data output stream + */ + def writeAsPickle(elem: Any, dOut: DataOutputStream) { if (elem.isInstanceOf[Array[Byte]]) { - elem.asInstanceOf[Array[Byte]] + val arr = elem.asInstanceOf[Array[Byte]] + dOut.writeInt(arr.length) + dOut.write(arr) } else if (elem.isInstanceOf[scala.Tuple2[Array[Byte], Array[Byte]]]) { val t = elem.asInstanceOf[scala.Tuple2[Array[Byte], Array[Byte]]] + val length = t._1.length + t._2.length - 3 - 3 + 4 // stripPickle() removes 3 bytes + dOut.writeInt(length) dOut.writeByte(Pickle.PROTO) dOut.writeByte(Pickle.TWO) dOut.write(PythonRDD.stripPickle(t._1)) dOut.write(PythonRDD.stripPickle(t._2)) dOut.writeByte(Pickle.TUPLE2) dOut.writeByte(Pickle.STOP) - baos.toByteArray() } else if (elem.isInstanceOf[String]) { // For uniformity, strings are wrapped into Pickles. val s = elem.asInstanceOf[String].getBytes("UTF-8") + val length = 2 + 1 + 4 + s.length + 1 + dOut.writeInt(length) dOut.writeByte(Pickle.PROTO) dOut.writeByte(Pickle.TWO) dOut.write(Pickle.BINUNICODE) dOut.writeInt(Integer.reverseBytes(s.length)) dOut.write(s) dOut.writeByte(Pickle.STOP) - baos.toByteArray() } else { throw new Exception("Unexpected RDD type") } } - def pickleFile(sc: JavaSparkContext, filename: String, parallelism: Int) : + def readRDDFromPickleFile(sc: JavaSparkContext, filename: String, parallelism: Int) : JavaRDD[Array[Byte]] = { val file = new DataInputStream(new FileInputStream(filename)) val objs = new collection.mutable.ArrayBuffer[Array[Byte]] @@ -221,11 +202,12 @@ object PythonRDD { JavaRDD.fromRDD(sc.sc.parallelize(objs, parallelism)) } - def arrayAsPickle(arr : Any) : Array[Byte] = { - val pickles : Array[Byte] = arr.asInstanceOf[Array[Any]].map(asPickle).map(stripPickle).flatten - - Array[Byte](Pickle.PROTO, Pickle.TWO, Pickle.EMPTY_LIST, Pickle.MARK) ++ pickles ++ - Array[Byte] (Pickle.APPENDS, Pickle.STOP) + def writeArrayToPickleFile[T](items: Array[T], filename: String) { + val file = new DataOutputStream(new FileOutputStream(filename)) + for (item <- items) { + writeAsPickle(item, file) + } + file.close() } } diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 50d57e5317..19f9f9e133 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -14,9 +14,8 @@ class SparkContext(object): gateway = launch_gateway() jvm = gateway.jvm - pickleFile = jvm.spark.api.python.PythonRDD.pickleFile - asPickle = jvm.spark.api.python.PythonRDD.asPickle - arrayAsPickle = jvm.spark.api.python.PythonRDD.arrayAsPickle + readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile + writeArrayToPickleFile = jvm.PythonRDD.writeArrayToPickleFile def __init__(self, master, name, defaultParallelism=None): self.master = master @@ -45,11 +44,11 @@ class SparkContext(object): # because it sends O(n) Py4J commands. As an alternative, serialized # objects are written to a file and loaded through textFile(). tempFile = NamedTemporaryFile(delete=False) + atexit.register(lambda: os.unlink(tempFile.name)) for x in c: write_with_length(dump_pickle(x), tempFile) tempFile.close() - atexit.register(lambda: os.unlink(tempFile.name)) - jrdd = self.pickleFile(self._jsc, tempFile.name, numSlices) + jrdd = self.readRDDFromPickleFile(self._jsc, tempFile.name, numSlices) return RDD(jrdd, self) def textFile(self, name, minSplits=None): diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 708ea6eb55..01908cff96 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,13 +1,15 @@ +import atexit from base64 import standard_b64encode as b64enc from collections import defaultdict from itertools import chain, ifilter, imap import os import shlex from subprocess import Popen, PIPE +from tempfile import NamedTemporaryFile from threading import Thread from pyspark import cloudpickle -from pyspark.serializers import dump_pickle, load_pickle +from pyspark.serializers import dump_pickle, load_pickle, read_from_pickle_file from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup @@ -145,10 +147,30 @@ class RDD(object): self.map(f).collect() # Force evaluation def collect(self): + # To minimize the number of transfers between Python and Java, we'll + # flatten each partition into a list before collecting it. Due to + # pipelining, this should add minimal overhead. def asList(iterator): yield list(iterator) - pickles = self.mapPartitions(asList)._jrdd.rdd().collect() - return list(chain.from_iterable(load_pickle(bytes(p)) for p in pickles)) + picklesInJava = self.mapPartitions(asList)._jrdd.rdd().collect() + return list(chain.from_iterable(self._collect_array_through_file(picklesInJava))) + + def _collect_array_through_file(self, array): + # Transferring lots of data through Py4J can be slow because + # socket.readline() is inefficient. Instead, we'll dump the data to a + # file and read it back. + tempFile = NamedTemporaryFile(delete=False) + tempFile.close() + def clean_up_file(): + try: os.unlink(tempFile.name) + except: pass + atexit.register(clean_up_file) + self.ctx.writeArrayToPickleFile(array, tempFile.name) + # Read the data into Python and deserialize it: + with open(tempFile.name, 'rb') as tempFile: + for item in read_from_pickle_file(tempFile): + yield item + os.unlink(tempFile.name) def reduce(self, f): """ @@ -220,15 +242,15 @@ class RDD(object): >>> sc.parallelize([2, 3, 4]).take(2) [2, 3] """ - pickle = self.ctx.arrayAsPickle(self._jrdd.rdd().take(num)) - return load_pickle(bytes(pickle)) + picklesInJava = self._jrdd.rdd().take(num) + return list(self._collect_array_through_file(picklesInJava)) def first(self): """ >>> sc.parallelize([2, 3, 4]).first() 2 """ - return load_pickle(bytes(self.ctx.asPickle(self._jrdd.first()))) + return self.take(1)[0] def saveAsTextFile(self, path): def func(iterator): diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index 21ef8b106c..bfcdda8f12 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -33,3 +33,11 @@ def read_with_length(stream): if obj == "": raise EOFError return obj + + +def read_from_pickle_file(stream): + try: + while True: + yield load_pickle(read_with_length(stream)) + except EOFError: + return diff --git a/pyspark/pyspark/worker.py b/pyspark/pyspark/worker.py index 62824a1c9b..9f6b507dbd 100644 --- a/pyspark/pyspark/worker.py +++ b/pyspark/pyspark/worker.py @@ -8,7 +8,7 @@ from base64 import standard_b64decode from pyspark.broadcast import Broadcast, _broadcastRegistry from pyspark.cloudpickle import CloudPickler from pyspark.serializers import write_with_length, read_with_length, \ - read_long, read_int, dump_pickle, load_pickle + read_long, read_int, dump_pickle, load_pickle, read_from_pickle_file # Redirect stdout to stderr so that users must return values from functions. @@ -20,14 +20,6 @@ def load_obj(): return load_pickle(standard_b64decode(sys.stdin.readline().strip())) -def read_input(): - try: - while True: - yield load_pickle(read_with_length(sys.stdin)) - except EOFError: - return - - def main(): num_broadcast_variables = read_int(sys.stdin) for _ in range(num_broadcast_variables): @@ -40,7 +32,7 @@ def main(): dumps = lambda x: x else: dumps = dump_pickle - for obj in func(read_input()): + for obj in func(read_from_pickle_file(sys.stdin)): write_with_length(dumps(obj), old_stdout) From e2dad15621f5dc15275b300df05483afde5025a0 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Wed, 26 Dec 2012 17:34:24 -0800 Subject: [PATCH 23/85] Add support for batched serialization of Python objects in PySpark. --- pyspark/pyspark/context.py | 3 +- pyspark/pyspark/rdd.py | 57 +++++++++++++++++++++++----------- pyspark/pyspark/serializers.py | 34 +++++++++++++++++++- 3 files changed, 74 insertions(+), 20 deletions(-) diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 19f9f9e133..032619693a 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -17,13 +17,14 @@ class SparkContext(object): readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile writeArrayToPickleFile = jvm.PythonRDD.writeArrayToPickleFile - def __init__(self, master, name, defaultParallelism=None): + def __init__(self, master, name, defaultParallelism=None, batchSize=-1): self.master = master self.name = name self._jsc = self.jvm.JavaSparkContext(master, name) self.defaultParallelism = \ defaultParallelism or self._jsc.sc().defaultParallelism() self.pythonExec = os.environ.get("PYSPARK_PYTHON_EXEC", 'python') + self.batchSize = batchSize # -1 represents a unlimited batch size # Broadcast's __reduce__ method stores Broadcast instances here. # This allows other code to determine which Broadcast instances have # been pickled, so it can determine which Java broadcast objects to diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 01908cff96..d7081dffd2 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -2,6 +2,7 @@ import atexit from base64 import standard_b64encode as b64enc from collections import defaultdict from itertools import chain, ifilter, imap +import operator import os import shlex from subprocess import Popen, PIPE @@ -9,7 +10,8 @@ from tempfile import NamedTemporaryFile from threading import Thread from pyspark import cloudpickle -from pyspark.serializers import dump_pickle, load_pickle, read_from_pickle_file +from pyspark.serializers import batched, Batch, dump_pickle, load_pickle, \ + read_from_pickle_file from pyspark.join import python_join, python_left_outer_join, \ python_right_outer_join, python_cogroup @@ -83,6 +85,11 @@ class RDD(object): >>> rdd = sc.parallelize([1, 1, 2, 3]) >>> rdd.union(rdd).collect() [1, 1, 2, 3, 1, 1, 2, 3] + + # Union of batched and unbatched RDDs: + >>> batchedRDD = sc.parallelize([Batch([1, 2, 3, 4, 5])]) + >>> rdd.union(batchedRDD).collect() + [1, 1, 2, 3, 1, 2, 3, 4, 5] """ return RDD(self._jrdd.union(other._jrdd), self.ctx) @@ -147,13 +154,8 @@ class RDD(object): self.map(f).collect() # Force evaluation def collect(self): - # To minimize the number of transfers between Python and Java, we'll - # flatten each partition into a list before collecting it. Due to - # pipelining, this should add minimal overhead. - def asList(iterator): - yield list(iterator) - picklesInJava = self.mapPartitions(asList)._jrdd.rdd().collect() - return list(chain.from_iterable(self._collect_array_through_file(picklesInJava))) + picklesInJava = self._jrdd.rdd().collect() + return list(self._collect_array_through_file(picklesInJava)) def _collect_array_through_file(self, array): # Transferring lots of data through Py4J can be slow because @@ -214,12 +216,21 @@ class RDD(object): # TODO: aggregate + def sum(self): + """ + >>> sc.parallelize([1.0, 2.0, 3.0]).sum() + 6.0 + """ + return self.mapPartitions(lambda x: [sum(x)]).reduce(operator.add) + def count(self): """ >>> sc.parallelize([2, 3, 4]).count() - 3L + 3 + >>> sc.parallelize([Batch([2, 3, 4])]).count() + 3 """ - return self._jrdd.count() + return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum() def countByValue(self): """ @@ -342,24 +353,23 @@ class RDD(object): """ if numSplits is None: numSplits = self.ctx.defaultParallelism + # Transferring O(n) objects to Java is too expensive. Instead, we'll + # form the hash buckets in Python, transferring O(numSplits) objects + # to Java. Each object is a (splitNumber, [objects]) pair. def add_shuffle_key(iterator): buckets = defaultdict(list) for (k, v) in iterator: buckets[hashFunc(k) % numSplits].append((k, v)) for (split, items) in buckets.iteritems(): yield str(split) - yield dump_pickle(items) + yield dump_pickle(Batch(items)) keyed = PipelinedRDD(self, add_shuffle_key) keyed._bypass_serializer = True pairRDD = self.ctx.jvm.PairwiseRDD(keyed._jrdd.rdd()).asJavaPairRDD() partitioner = self.ctx.jvm.spark.api.python.PythonPartitioner(numSplits) - # Transferring O(n) objects to Java is too expensive. Instead, we'll - # form the hash buckets in Python, transferring O(numSplits) objects - # to Java. Each object is a (splitNumber, [objects]) pair. jrdd = pairRDD.partitionBy(partitioner) jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) - # Flatten the resulting RDD: - return RDD(jrdd, self.ctx).flatMap(lambda items: items) + return RDD(jrdd, self.ctx) def combineByKey(self, createCombiner, mergeValue, mergeCombiners, numSplits=None): @@ -478,8 +488,19 @@ class PipelinedRDD(RDD): def _jrdd(self): if self._jrdd_val: return self._jrdd_val - funcs = [self.func, self._bypass_serializer] - pipe_command = ' '.join(b64enc(cloudpickle.dumps(f)) for f in funcs) + func = self.func + if not self._bypass_serializer and self.ctx.batchSize != 1: + oldfunc = self.func + batchSize = self.ctx.batchSize + if batchSize == -1: # unlimited batch size + def batched_func(iterator): + yield Batch(list(oldfunc(iterator))) + else: + def batched_func(iterator): + return batched(oldfunc(iterator), batchSize) + func = batched_func + cmds = [func, self._bypass_serializer] + pipe_command = ' '.join(b64enc(cloudpickle.dumps(f)) for f in cmds) broadcast_vars = ListConverter().convert( [x._jbroadcast for x in self.ctx._pickled_broadcast_vars], self.ctx.gateway._gateway_client) diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index bfcdda8f12..4ed925697c 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -2,6 +2,33 @@ import struct import cPickle +class Batch(object): + """ + Used to store multiple RDD entries as a single Java object. + + This relieves us from having to explicitly track whether an RDD + is stored as batches of objects and avoids problems when processing + the union() of batched and unbatched RDDs (e.g. the union() of textFile() + with another RDD). + """ + def __init__(self, items): + self.items = items + + +def batched(iterator, batchSize): + items = [] + count = 0 + for item in iterator: + items.append(item) + count += 1 + if count == batchSize: + yield Batch(items) + items = [] + count = [] + if items: + yield Batch(items) + + def dump_pickle(obj): return cPickle.dumps(obj, 2) @@ -38,6 +65,11 @@ def read_with_length(stream): def read_from_pickle_file(stream): try: while True: - yield load_pickle(read_with_length(stream)) + obj = load_pickle(read_with_length(stream)) + if type(obj) == Batch: # We don't care about inheritance + for item in obj.items: + yield item + else: + yield obj except EOFError: return From 1dca0c51804b9c94709ec9cc0544b8dfb7afe59f Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Wed, 26 Dec 2012 18:23:06 -0800 Subject: [PATCH 24/85] Remove debug output from PythonPartitioner. --- core/src/main/scala/spark/api/python/PythonPartitioner.scala | 2 -- 1 file changed, 2 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonPartitioner.scala b/core/src/main/scala/spark/api/python/PythonPartitioner.scala index ef9f808fb2..606a80d1eb 100644 --- a/core/src/main/scala/spark/api/python/PythonPartitioner.scala +++ b/core/src/main/scala/spark/api/python/PythonPartitioner.scala @@ -16,8 +16,6 @@ class PythonPartitioner(override val numPartitions: Int) extends Partitioner { else { val hashCode = { if (key.isInstanceOf[Array[Byte]]) { - System.err.println("Dumping a byte array!" + Arrays.hashCode(key.asInstanceOf[Array[Byte]]) - ) Arrays.hashCode(key.asInstanceOf[Array[Byte]]) } else From 2d98fff0651af4d527f41ba50c01f453fa049464 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 27 Dec 2012 10:13:29 -0800 Subject: [PATCH 25/85] Add IPython support to pyspark-shell. Suggested by / based on code from @MLnick --- pyspark/README | 3 +++ pyspark/pyspark/shell.py | 25 +++++++++++++++++-------- pyspark/requirements.txt | 1 + 3 files changed, 21 insertions(+), 8 deletions(-) diff --git a/pyspark/README b/pyspark/README index 55490e1a83..461176de7d 100644 --- a/pyspark/README +++ b/pyspark/README @@ -38,6 +38,9 @@ interacting with Java processes. It can be installed from https://github.com/bartdag/py4j; make sure to install a version that contains at least the commits through b7924aabe9. +PySpark requires the `argparse` module, which is included in Python 2.7 +and is is available for Python 2.6 through `pip` or `easy_install`. + PySpark uses the `PYTHONPATH` environment variable to search for Python classes; Py4J should be on this path, along with any libraries used by PySpark programs. `PYTHONPATH` will be automatically shipped to worker diff --git a/pyspark/pyspark/shell.py b/pyspark/pyspark/shell.py index 7ef30894cb..7012884abc 100644 --- a/pyspark/pyspark/shell.py +++ b/pyspark/pyspark/shell.py @@ -1,21 +1,30 @@ """ An interactive shell. """ +import argparse # argparse is avaiable for Python < 2.7 through easy_install. import code import sys from pyspark.context import SparkContext -def main(master='local'): +def main(master='local', ipython=False): sc = SparkContext(master, 'PySparkShell') - print "Spark context available as sc." - code.interact(local={'sc': sc}) + user_ns = {'sc' : sc} + banner = "Spark context avaiable as sc." + if ipython: + import IPython + IPython.embed(user_ns=user_ns, banner2=banner) + else: + print banner + code.interact(local=user_ns) if __name__ == '__main__': - if len(sys.argv) > 1: - master = sys.argv[1] - else: - master = 'local' - main(master) + parser = argparse.ArgumentParser() + parser.add_argument("master", help="Spark master host (default='local')", + nargs='?', type=str, default="local") + parser.add_argument("-i", "--ipython", help="Run IPython shell", + action="store_true") + args = parser.parse_args() + main(args.master, args.ipython) diff --git a/pyspark/requirements.txt b/pyspark/requirements.txt index 48fa2ab105..2464ca0074 100644 --- a/pyspark/requirements.txt +++ b/pyspark/requirements.txt @@ -4,3 +4,4 @@ # install Py4J from git once https://github.com/pypa/pip/pull/526 is merged. # git+git://github.com/bartdag/py4j.git@b7924aabe9c5e63f0a4d8bbd17019534c7ec014e +argparse From 85b8f2c64f0fc4be5645d8736629fc082cb3587b Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 27 Dec 2012 17:55:33 -0800 Subject: [PATCH 26/85] Add epydoc API documentation for PySpark. --- docs/README.md | 8 +- docs/_layouts/global.html | 10 +- docs/_plugins/copy_api_dirs.rb | 17 +++ pyspark/epydoc.conf | 19 ++++ pyspark/pyspark/context.py | 24 ++++ pyspark/pyspark/rdd.py | 195 ++++++++++++++++++++++++++++++--- 6 files changed, 254 insertions(+), 19 deletions(-) create mode 100644 pyspark/epydoc.conf diff --git a/docs/README.md b/docs/README.md index 092153070e..887f407f18 100644 --- a/docs/README.md +++ b/docs/README.md @@ -25,10 +25,12 @@ To mark a block of code in your markdown to be syntax highlighted by jekyll duri // supported languages too. {% endhighlight %} -## Scaladoc +## API Docs (Scaladoc and Epydoc) You can build just the Spark scaladoc by running `sbt/sbt doc` from the SPARK_PROJECT_ROOT directory. -When you run `jekyll` in the docs directory, it will also copy over the scala doc for the various Spark subprojects into the docs directory (and then also into the _site directory). We use a jekyll plugin to run `sbt/sbt doc` before building the site so if you haven't run it (recently) it may take some time as it generates all of the scaladoc. +Similarly, you can build just the PySpark epydoc by running `epydoc --config epydoc.conf` from the SPARK_PROJECT_ROOT/pyspark directory. -NOTE: To skip the step of building and copying over the scaladoc when you build the docs, run `SKIP_SCALADOC=1 jekyll`. +When you run `jekyll` in the docs directory, it will also copy over the scaladoc for the various Spark subprojects into the docs directory (and then also into the _site directory). We use a jekyll plugin to run `sbt/sbt doc` before building the site so if you haven't run it (recently) it may take some time as it generates all of the scaladoc. The jekyll plugin also generates the PySpark docs using [epydoc](http://epydoc.sourceforge.net/). + +NOTE: To skip the step of building and copying over the scaladoc when you build the docs, run `SKIP_SCALADOC=1 jekyll`. Similarly, `SKIP_EPYDOC=1 jekyll` will skip PySpark API doc generation. diff --git a/docs/_layouts/global.html b/docs/_layouts/global.html index 41ad5242c9..43a5fa3e1c 100755 --- a/docs/_layouts/global.html +++ b/docs/_layouts/global.html @@ -49,8 +49,14 @@
  • Java
    • - -
  • API (Scaladoc)
    • + +
  • + API + +
  • Deploying diff --git a/docs/_plugins/copy_api_dirs.rb b/docs/_plugins/copy_api_dirs.rb index e61c105449..577f3ebe70 100644 --- a/docs/_plugins/copy_api_dirs.rb +++ b/docs/_plugins/copy_api_dirs.rb @@ -28,3 +28,20 @@ if ENV['SKIP_SCALADOC'] != '1' cp_r(source + "/.", dest) end end + +if ENV['SKIP_EPYDOC'] != '1' + puts "Moving to pyspark directory and building epydoc." + cd("../pyspark") + puts `epydoc --config epydoc.conf` + + puts "Moving back into docs dir." + cd("../docs") + + puts "echo making directory pyspark" + mkdir_p "pyspark" + + puts "cp -r ../pyspark/docs/. api/pyspark" + cp_r("../pyspark/docs/.", "api/pyspark") + + cd("..") +end diff --git a/pyspark/epydoc.conf b/pyspark/epydoc.conf new file mode 100644 index 0000000000..91ac984ba2 --- /dev/null +++ b/pyspark/epydoc.conf @@ -0,0 +1,19 @@ +[epydoc] # Epydoc section marker (required by ConfigParser) + +# Information about the project. +name: PySpark +url: http://spark-project.org + +# The list of modules to document. Modules can be named using +# dotted names, module filenames, or package directory names. +# This option may be repeated. +modules: pyspark + +# Write html output to the directory "apidocs" +output: html +target: docs/ + +private: no + +exclude: pyspark.cloudpickle pyspark.worker pyspark.join pyspark.serializers + pyspark.java_gateway pyspark.examples pyspark.shell diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 032619693a..7758d3e375 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -11,6 +11,11 @@ from py4j.java_collections import ListConverter class SparkContext(object): + """ + Main entry point for Spark functionality. A SparkContext represents the + connection to a Spark cluster, and can be used to create L{RDD}s and + broadcast variables on that cluster. + """ gateway = launch_gateway() jvm = gateway.jvm @@ -36,10 +41,16 @@ class SparkContext(object): self._jsc.stop() def stop(self): + """ + Shut down the SparkContext. + """ self._jsc.stop() self._jsc = None def parallelize(self, c, numSlices=None): + """ + Distribute a local Python collection to form an RDD. + """ numSlices = numSlices or self.defaultParallelism # Calling the Java parallelize() method with an ArrayList is too slow, # because it sends O(n) Py4J commands. As an alternative, serialized @@ -53,17 +64,30 @@ class SparkContext(object): return RDD(jrdd, self) def textFile(self, name, minSplits=None): + """ + Read a text file from HDFS, a local file system (available on all + nodes), or any Hadoop-supported file system URI, and return it as an + RDD of Strings. + """ minSplits = minSplits or min(self.defaultParallelism, 2) jrdd = self._jsc.textFile(name, minSplits) return RDD(jrdd, self) def union(self, rdds): + """ + Build the union of a list of RDDs + """ first = rdds[0]._jrdd rest = [x._jrdd for x in rdds[1:]] rest = ListConverter().convert(rest, self.gateway._gateway_client) return RDD(self._jsc.union(first, rest), self) def broadcast(self, value): + """ + Broadcast a read-only variable to the cluster, returning a C{Broadcast} + object for reading it in distributed functions. The variable will be + sent to each cluster only once. + """ jbroadcast = self._jsc.broadcast(bytearray(dump_pickle(value))) return Broadcast(jbroadcast.id(), value, jbroadcast, self._pickled_broadcast_vars) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index d7081dffd2..5af105ef62 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -18,24 +18,50 @@ from pyspark.join import python_join, python_left_outer_join, \ from py4j.java_collections import ListConverter, MapConverter +__all__ = ["RDD"] + + class RDD(object): + """ + A Resilient Distributed Dataset (RDD), the basic abstraction in Spark. + Represents an immutable, partitioned collection of elements that can be + operated on in parallel. + """ def __init__(self, jrdd, ctx): self._jrdd = jrdd self.is_cached = False self.ctx = ctx + @property + def context(self): + """ + The L{SparkContext} that this RDD was created on. + """ + return self.ctx + def cache(self): + """ + Persist this RDD with the default storage level (C{MEMORY_ONLY}). + """ self.is_cached = True self._jrdd.cache() return self + # TODO persist(self, storageLevel) + def map(self, f, preservesPartitioning=False): + """ + Return a new RDD containing the distinct elements in this RDD. + """ def func(iterator): return imap(f, iterator) return PipelinedRDD(self, func, preservesPartitioning) - def flatMap(self, f): + def flatMap(self, f, preservesPartitioning=False): """ + Return a new RDD by first applying a function to all elements of this + RDD, and then flattening the results. + >>> rdd = sc.parallelize([2, 3, 4]) >>> sorted(rdd.flatMap(lambda x: range(1, x)).collect()) [1, 1, 1, 2, 2, 3] @@ -43,19 +69,25 @@ class RDD(object): [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] """ def func(iterator): return chain.from_iterable(imap(f, iterator)) - return self.mapPartitions(func) + return self.mapPartitions(func, preservesPartitioning) - def mapPartitions(self, f): + def mapPartitions(self, f, preservesPartitioning=False): """ + Return a new RDD by applying a function to each partition of this RDD. + >>> rdd = sc.parallelize([1, 2, 3, 4], 2) >>> def f(iterator): yield sum(iterator) >>> rdd.mapPartitions(f).collect() [3, 7] """ - return PipelinedRDD(self, f) + return PipelinedRDD(self, f, preservesPartitioning) + + # TODO: mapPartitionsWithSplit def filter(self, f): """ + Return a new RDD containing only the elements that satisfy a predicate. + >>> rdd = sc.parallelize([1, 2, 3, 4, 5]) >>> rdd.filter(lambda x: x % 2 == 0).collect() [2, 4] @@ -65,6 +97,8 @@ class RDD(object): def distinct(self): """ + Return a new RDD containing the distinct elements in this RDD. + >>> sorted(sc.parallelize([1, 1, 2, 3]).distinct().collect()) [1, 2, 3] """ @@ -72,21 +106,25 @@ class RDD(object): .reduceByKey(lambda x, _: x) \ .map(lambda (x, _): x) - def sample(self, withReplacement, fraction, seed): - jrdd = self._jrdd.sample(withReplacement, fraction, seed) - return RDD(jrdd, self.ctx) + # TODO: sampling needs to be re-implemented due to Batch + #def sample(self, withReplacement, fraction, seed): + # jrdd = self._jrdd.sample(withReplacement, fraction, seed) + # return RDD(jrdd, self.ctx) - def takeSample(self, withReplacement, num, seed): - vals = self._jrdd.takeSample(withReplacement, num, seed) - return [load_pickle(bytes(x)) for x in vals] + #def takeSample(self, withReplacement, num, seed): + # vals = self._jrdd.takeSample(withReplacement, num, seed) + # return [load_pickle(bytes(x)) for x in vals] def union(self, other): """ + Return the union of this RDD and another one. + >>> rdd = sc.parallelize([1, 1, 2, 3]) >>> rdd.union(rdd).collect() [1, 1, 2, 3, 1, 1, 2, 3] - # Union of batched and unbatched RDDs: + Union of batched and unbatched RDDs (internal test): + >>> batchedRDD = sc.parallelize([Batch([1, 2, 3, 4, 5])]) >>> rdd.union(batchedRDD).collect() [1, 1, 2, 3, 1, 2, 3, 4, 5] @@ -95,6 +133,8 @@ class RDD(object): def __add__(self, other): """ + Return the union of this RDD and another one. + >>> rdd = sc.parallelize([1, 1, 2, 3]) >>> (rdd + rdd).collect() [1, 1, 2, 3, 1, 1, 2, 3] @@ -107,6 +147,9 @@ class RDD(object): def glom(self): """ + Return an RDD created by coalescing all elements within each partition + into a list. + >>> rdd = sc.parallelize([1, 2, 3, 4], 2) >>> rdd.glom().first() [1, 2] @@ -116,6 +159,10 @@ class RDD(object): def cartesian(self, other): """ + Return the Cartesian product of this RDD and another one, that is, the + RDD of all pairs of elements C{(a, b)} where C{a} is in C{self} and + C{b} is in C{other}. + >>> rdd = sc.parallelize([1, 2]) >>> sorted(rdd.cartesian(rdd).collect()) [(1, 1), (1, 2), (2, 1), (2, 2)] @@ -124,6 +171,8 @@ class RDD(object): def groupBy(self, f, numSplits=None): """ + Return an RDD of grouped items. + >>> rdd = sc.parallelize([1, 1, 2, 3, 5, 8]) >>> result = rdd.groupBy(lambda x: x % 2).collect() >>> sorted([(x, sorted(y)) for (x, y) in result]) @@ -133,6 +182,8 @@ class RDD(object): def pipe(self, command, env={}): """ + Return an RDD created by piping elements to a forked external process. + >>> sc.parallelize([1, 2, 3]).pipe('cat').collect() ['1', '2', '3'] """ @@ -148,12 +199,17 @@ class RDD(object): def foreach(self, f): """ + Applies a function to all elements of this RDD. + >>> def f(x): print x >>> sc.parallelize([1, 2, 3, 4, 5]).foreach(f) """ self.map(f).collect() # Force evaluation def collect(self): + """ + Return a list that contains all of the elements in this RDD. + """ picklesInJava = self._jrdd.rdd().collect() return list(self._collect_array_through_file(picklesInJava)) @@ -176,6 +232,9 @@ class RDD(object): def reduce(self, f): """ + Reduces the elements of this RDD using the specified associative binary + operator. + >>> from operator import add >>> sc.parallelize([1, 2, 3, 4, 5]).reduce(add) 15 @@ -198,9 +257,11 @@ class RDD(object): """ Aggregate the elements of each partition, and then the results for all the partitions, using a given associative function and a neutral "zero - value." The function op(t1, t2) is allowed to modify t1 and return it + value." + + The function C{op(t1, t2)} is allowed to modify C{t1} and return it as its result value to avoid object allocation; however, it should not - modify t2. + modify C{t2}. >>> from operator import add >>> sc.parallelize([1, 2, 3, 4, 5]).fold(0, add) @@ -218,6 +279,8 @@ class RDD(object): def sum(self): """ + Add up the elements in this RDD. + >>> sc.parallelize([1.0, 2.0, 3.0]).sum() 6.0 """ @@ -225,6 +288,8 @@ class RDD(object): def count(self): """ + Return the number of elements in this RDD. + >>> sc.parallelize([2, 3, 4]).count() 3 >>> sc.parallelize([Batch([2, 3, 4])]).count() @@ -234,6 +299,9 @@ class RDD(object): def countByValue(self): """ + Return the count of each unique value in this RDD as a dictionary of + (value, count) pairs. + >>> sorted(sc.parallelize([1, 2, 1, 2, 2], 2).countByValue().items()) [(1, 2), (2, 3)] """ @@ -250,6 +318,12 @@ class RDD(object): def take(self, num): """ + Take the first num elements of the RDD. + + This currently scans the partitions *one by one*, so it will be slow if + a lot of partitions are required. In that case, use L{collect} to get + the whole RDD instead. + >>> sc.parallelize([2, 3, 4]).take(2) [2, 3] """ @@ -258,12 +332,18 @@ class RDD(object): def first(self): """ + Return the first element in this RDD. + >>> sc.parallelize([2, 3, 4]).first() 2 """ return self.take(1)[0] + # TODO: add test and fix for use with Batch def saveAsTextFile(self, path): + """ + Save this RDD as a text file, using string representations of elements. + """ def func(iterator): return (str(x).encode("utf-8") for x in iterator) keyed = PipelinedRDD(self, func) @@ -274,6 +354,8 @@ class RDD(object): def collectAsMap(self): """ + Return the key-value pairs in this RDD to the master as a dictionary. + >>> m = sc.parallelize([(1, 2), (3, 4)]).collectAsMap() >>> m[1] 2 @@ -284,6 +366,14 @@ class RDD(object): def reduceByKey(self, func, numSplits=None): """ + Merge the values for each key using an associative reduce function. + + This will also perform the merging locally on each mapper before + sending results to a reducer, similarly to a "combiner" in MapReduce. + + Output will be hash-partitioned with C{numSplits} splits, or the + default parallelism level if C{numSplits} is not specified. + >>> from operator import add >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(rdd.reduceByKey(add).collect()) @@ -293,6 +383,12 @@ class RDD(object): def reduceByKeyLocally(self, func): """ + Merge the values for each key using an associative reduce function, but + return the results immediately to the master as a dictionary. + + This will also perform the merging locally on each mapper before + sending results to a reducer, similarly to a "combiner" in MapReduce. + >>> from operator import add >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(rdd.reduceByKeyLocally(add).items()) @@ -311,6 +407,9 @@ class RDD(object): def countByKey(self): """ + Count the number of elements for each key, and return the result to the + master as a dictionary. + >>> rdd = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(rdd.countByKey().items()) [('a', 2), ('b', 1)] @@ -319,6 +418,14 @@ class RDD(object): def join(self, other, numSplits=None): """ + Return an RDD containing all pairs of elements with matching keys in + C{self} and C{other}. + + Each pair of elements will be returned as a (k, (v1, v2)) tuple, where + (k, v1) is in C{self} and (k, v2) is in C{other}. + + Performs a hash join across the cluster. + >>> x = sc.parallelize([("a", 1), ("b", 4)]) >>> y = sc.parallelize([("a", 2), ("a", 3)]) >>> sorted(x.join(y).collect()) @@ -328,6 +435,14 @@ class RDD(object): def leftOuterJoin(self, other, numSplits=None): """ + Perform a left outer join of C{self} and C{other}. + + For each element (k, v) in C{self}, the resulting RDD will either + contain all pairs (k, (v, w)) for w in C{other}, or the pair + (k, (v, None)) if no elements in other have key k. + + Hash-partitions the resulting RDD into the given number of partitions. + >>> x = sc.parallelize([("a", 1), ("b", 4)]) >>> y = sc.parallelize([("a", 2)]) >>> sorted(x.leftOuterJoin(y).collect()) @@ -337,6 +452,14 @@ class RDD(object): def rightOuterJoin(self, other, numSplits=None): """ + Perform a right outer join of C{self} and C{other}. + + For each element (k, w) in C{other}, the resulting RDD will either + contain all pairs (k, (v, w)) for v in this, or the pair (k, (None, w)) + if no elements in C{self} have key k. + + Hash-partitions the resulting RDD into the given number of partitions. + >>> x = sc.parallelize([("a", 1), ("b", 4)]) >>> y = sc.parallelize([("a", 2)]) >>> sorted(y.rightOuterJoin(x).collect()) @@ -344,8 +467,11 @@ class RDD(object): """ return python_right_outer_join(self, other, numSplits) + # TODO: add option to control map-side combining def partitionBy(self, numSplits, hashFunc=hash): """ + Return a copy of the RDD partitioned using the specified partitioner. + >>> pairs = sc.parallelize([1, 2, 3, 4, 2, 4, 1]).map(lambda x: (x, x)) >>> sets = pairs.partitionBy(2).glom().collect() >>> set(sets[0]).intersection(set(sets[1])) @@ -371,9 +497,27 @@ class RDD(object): jrdd = jrdd.map(self.ctx.jvm.ExtractValue()) return RDD(jrdd, self.ctx) + # TODO: add control over map-side aggregation def combineByKey(self, createCombiner, mergeValue, mergeCombiners, numSplits=None): """ + Generic function to combine the elements for each key using a custom + set of aggregation functions. + + Turns an RDD[(K, V)] into a result of type RDD[(K, C)], for a "combined + type" C. Note that V and C can be different -- for example, one might + group an RDD of type (Int, Int) into an RDD of type (Int, List[Int]). + + Users provide three functions: + + - C{createCombiner}, which turns a V into a C (e.g., creates + a one-element list) + - C{mergeValue}, to merge a V into a C (e.g., adds it to the end of + a list) + - C{mergeCombiners}, to combine two C's into a single one. + + In addition, users can control the partitioning of the output RDD. + >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> def f(x): return x >>> def add(a, b): return a + str(b) @@ -402,8 +546,12 @@ class RDD(object): return combiners.iteritems() return shuffled.mapPartitions(_mergeCombiners) + # TODO: support variant with custom partitioner def groupByKey(self, numSplits=None): """ + Group the values for each key in the RDD into a single sequence. + Hash-partitions the resulting RDD with into numSplits partitions. + >>> x = sc.parallelize([("a", 1), ("b", 1), ("a", 1)]) >>> sorted(x.groupByKey().collect()) [('a', [1, 1]), ('b', [1])] @@ -422,20 +570,39 @@ class RDD(object): return self.combineByKey(createCombiner, mergeValue, mergeCombiners, numSplits) + # TODO: add tests def flatMapValues(self, f): + """ + Pass each value in the key-value pair RDD through a flatMap function + without changing the keys; this also retains the original RDD's + partitioning. + """ flat_map_fn = lambda (k, v): ((k, x) for x in f(v)) - return self.flatMap(flat_map_fn) + return self.flatMap(flat_map_fn, preservesPartitioning=True) def mapValues(self, f): + """ + Pass each value in the key-value pair RDD through a map function + without changing the keys; this also retains the original RDD's + partitioning. + """ map_values_fn = lambda (k, v): (k, f(v)) return self.map(map_values_fn, preservesPartitioning=True) # TODO: support varargs cogroup of several RDDs. def groupWith(self, other): + """ + Alias for cogroup. + """ return self.cogroup(other) + # TODO: add variant with custom parittioner def cogroup(self, other, numSplits=None): """ + For each key k in C{self} or C{other}, return a resulting RDD that + contains a tuple with the list of values for that key in C{self} as well + as C{other}. + >>> x = sc.parallelize([("a", 1), ("b", 4)]) >>> y = sc.parallelize([("a", 2)]) >>> sorted(x.cogroup(y).collect()) From ac32447cd38beac8f6bc7a90be9fd24666bb46ad Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 27 Dec 2012 19:59:04 -0800 Subject: [PATCH 27/85] Use addFile() to ship code to cluster in PySpark. Add options to pyspark.SparkContext constructor. --- pyspark/pyspark/context.py | 77 ++++++++++++++++++++++++++++++++++---- pyspark/pyspark/rdd.py | 7 ++-- 2 files changed, 74 insertions(+), 10 deletions(-) diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 7758d3e375..988c81cd5d 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -22,20 +22,54 @@ class SparkContext(object): readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile writeArrayToPickleFile = jvm.PythonRDD.writeArrayToPickleFile - def __init__(self, master, name, defaultParallelism=None, batchSize=-1): + def __init__(self, master, jobName, sparkHome=None, pyFiles=None, + environment=None, batchSize=1024): + """ + Create a new SparkContext. + + @param master: Cluster URL to connect to + (e.g. mesos://host:port, spark://host:port, local[4]). + @param jobName: A name for your job, to display on the cluster web UI + @param sparkHome: Location where Spark is installed on cluster nodes. + @param pyFiles: Collection of .zip or .py files to send to the cluster + and add to PYTHONPATH. These can be paths on the local file + system or HDFS, HTTP, HTTPS, or FTP URLs. + @param environment: A dictionary of environment variables to set on + worker nodes. + @param batchSize: The number of Python objects represented as a single + Java object. Set 1 to disable batching or -1 to use an + unlimited batch size. + """ self.master = master - self.name = name - self._jsc = self.jvm.JavaSparkContext(master, name) - self.defaultParallelism = \ - defaultParallelism or self._jsc.sc().defaultParallelism() - self.pythonExec = os.environ.get("PYSPARK_PYTHON_EXEC", 'python') + self.jobName = jobName + self.sparkHome = sparkHome or None # None becomes null in Py4J + self.environment = environment or {} self.batchSize = batchSize # -1 represents a unlimited batch size + + # Create the Java SparkContext through Py4J + empty_string_array = self.gateway.new_array(self.jvm.String, 0) + self._jsc = self.jvm.JavaSparkContext(master, jobName, sparkHome, + empty_string_array) + + self.pythonExec = os.environ.get("PYSPARK_PYTHON_EXEC", 'python') # Broadcast's __reduce__ method stores Broadcast instances here. # This allows other code to determine which Broadcast instances have # been pickled, so it can determine which Java broadcast objects to # send. self._pickled_broadcast_vars = set() + # Deploy any code dependencies specified in the constructor + for path in (pyFiles or []): + self.addPyFile(path) + + @property + def defaultParallelism(self): + """ + Default level of parallelism to use when not given by user (e.g. for + reduce tasks) + """ + return self._jsc.sc().defaultParallelism() + def __del__(self): if self._jsc: self._jsc.stop() @@ -75,7 +109,7 @@ class SparkContext(object): def union(self, rdds): """ - Build the union of a list of RDDs + Build the union of a list of RDDs. """ first = rdds[0]._jrdd rest = [x._jrdd for x in rdds[1:]] @@ -91,3 +125,32 @@ class SparkContext(object): jbroadcast = self._jsc.broadcast(bytearray(dump_pickle(value))) return Broadcast(jbroadcast.id(), value, jbroadcast, self._pickled_broadcast_vars) + + def addFile(self, path): + """ + Add a file to be downloaded into the working directory of this Spark + job on every node. The C{path} passed can be either a local file, + a file in HDFS (or other Hadoop-supported filesystems), or an HTTP, + HTTPS or FTP URI. + """ + self._jsc.sc().addFile(path) + + def clearFiles(self): + """ + Clear the job's list of files added by L{addFile} or L{addPyFile} so + that they do not get downloaded to any new nodes. + """ + # TODO: remove added .py or .zip files from the PYTHONPATH? + self._jsc.sc().clearFiles() + + def addPyFile(self, path): + """ + Add a .py or .zip dependency for all tasks to be executed on this + SparkContext in the future. The C{path} passed can be either a local + file, a file in HDFS (or other Hadoop-supported filesystems), or an + HTTP, HTTPS or FTP URI. + """ + self.addFile(path) + filename = path.split("/")[-1] + os.environ["PYTHONPATH"] = \ + "%s:%s" % (filename, os.environ["PYTHONPATH"]) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 5af105ef62..bf32472d25 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -1,5 +1,6 @@ import atexit from base64 import standard_b64encode as b64enc +import copy from collections import defaultdict from itertools import chain, ifilter, imap import operator @@ -673,9 +674,9 @@ class PipelinedRDD(RDD): self.ctx.gateway._gateway_client) self.ctx._pickled_broadcast_vars.clear() class_manifest = self._prev_jrdd.classManifest() - env = MapConverter().convert( - {'PYTHONPATH' : os.environ.get("PYTHONPATH", "")}, - self.ctx.gateway._gateway_client) + env = copy.copy(self.ctx.environment) + env['PYTHONPATH'] = os.environ.get("PYTHONPATH", "") + env = MapConverter().convert(env, self.ctx.gateway._gateway_client) python_rdd = self.ctx.jvm.PythonRDD(self._prev_jrdd.rdd(), pipe_command, env, self.preservesPartitioning, self.ctx.pythonExec, broadcast_vars, class_manifest) From 665466dfff4f89196627a0777eabd3d3894cd296 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 27 Dec 2012 22:47:37 -0800 Subject: [PATCH 28/85] Simplify PySpark installation. - Bundle Py4J binaries, since it's hard to install - Uses Spark's `run` script to launch the Py4J gateway, inheriting the settings in spark-env.sh With these changes, (hopefully) nothing more than running `sbt/sbt package` will be necessary to run PySpark. --- pyspark/README | 23 ++------------------- pyspark/lib/PY4J_LICENSE.txt | 27 ++++++++++++++++++++++++ pyspark/lib/PY4J_VERSION.txt | 1 + pyspark/lib/py4j0.7.egg | Bin 0 -> 191756 bytes pyspark/lib/py4j0.7.jar | Bin 0 -> 103286 bytes pyspark/pyspark-shell | 2 +- pyspark/pyspark/__init__.py | 3 +++ pyspark/pyspark/java_gateway.py | 35 ++++++++++++++++++++++++-------- pyspark/pyspark/shell.py | 19 +++++++++-------- pyspark/requirements.txt | 7 ------- pyspark/run-pyspark | 2 +- run | 4 ++++ run2.cmd | 2 ++ 13 files changed, 78 insertions(+), 47 deletions(-) create mode 100644 pyspark/lib/PY4J_LICENSE.txt create mode 100644 pyspark/lib/PY4J_VERSION.txt create mode 100644 pyspark/lib/py4j0.7.egg create mode 100644 pyspark/lib/py4j0.7.jar delete mode 100644 pyspark/requirements.txt diff --git a/pyspark/README b/pyspark/README index 461176de7d..d8d521c72c 100644 --- a/pyspark/README +++ b/pyspark/README @@ -32,30 +32,11 @@ The `pyspark/pyspark/examples` directory contains a few complete examples. ## Installing PySpark - -PySpark requires a development version of Py4J, a Python library for -interacting with Java processes. It can be installed from -https://github.com/bartdag/py4j; make sure to install a version that -contains at least the commits through b7924aabe9. - -PySpark requires the `argparse` module, which is included in Python 2.7 -and is is available for Python 2.6 through `pip` or `easy_install`. - -PySpark uses the `PYTHONPATH` environment variable to search for Python -classes; Py4J should be on this path, along with any libraries used by -PySpark programs. `PYTHONPATH` will be automatically shipped to worker -machines, but the files that it points to must be present on each -machine. - -PySpark requires the Spark assembly JAR, which can be created by running -`sbt/sbt assembly` in the Spark directory. - -Additionally, `SPARK_HOME` should be set to the location of the Spark +# +To use PySpark, `SPARK_HOME` should be set to the location of the Spark package. ## Running PySpark The easiest way to run PySpark is to use the `run-pyspark` and `pyspark-shell` scripts, which are included in the `pyspark` directory. -These scripts automatically load the `spark-conf.sh` file, set -`SPARK_HOME`, and add the `pyspark` package to the `PYTHONPATH`. diff --git a/pyspark/lib/PY4J_LICENSE.txt b/pyspark/lib/PY4J_LICENSE.txt new file mode 100644 index 0000000000..a70279ca14 --- /dev/null +++ b/pyspark/lib/PY4J_LICENSE.txt @@ -0,0 +1,27 @@ + +Copyright (c) 2009-2011, Barthelemy Dagenais All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +- Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +- The name of the author may not be used to endorse or promote products +derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/pyspark/lib/PY4J_VERSION.txt b/pyspark/lib/PY4J_VERSION.txt new file mode 100644 index 0000000000..04a0cd52a8 --- /dev/null +++ b/pyspark/lib/PY4J_VERSION.txt @@ -0,0 +1 @@ +b7924aabe9c5e63f0a4d8bbd17019534c7ec014e diff --git a/pyspark/lib/py4j0.7.egg b/pyspark/lib/py4j0.7.egg new file mode 100644 index 0000000000000000000000000000000000000000..f8a339d8eef591afce7e7e0e5beb73355bf0a4bf GIT binary patch literal 191756 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

    U@A>UUXm)V+{W_>;Fj|vv*k8` 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

    {?qV|zhOl;*XLkttE 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 literal 0 HcmV?d00001 diff --git a/pyspark/lib/py4j0.7.jar b/pyspark/lib/py4j0.7.jar new file mode 100644 index 0000000000000000000000000000000000000000..73b7ddb7d115be2fb1ba4cf8003fe90c662feef6 GIT binary patch literal 103286 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%0DYnL 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%0AU}-CW@9{%#q)Rqs&fBm?mLLVn3f1hY&S|3Ayl` z6&D+o_edYT&uwc+x9AneR&y%Q!;)f7c0?aVcjOPAp+~2zqf_BEuK1!)!kw5Ak%a%G zgeN>J=q_A)i<~`5DblLsZd`ktkUbhh&l6pTX5dCzft+Fw&Ee>5o7i6)Y~^;w%j2Bvgdo!W4wYS1yT_fG0b{IcukEysXA?}UL{9GGvot9uxm`#{SM z*=Ak@opLZ~rJ@6mU(*=Sj1Z6&GH9OSdgL1@Zy&q3_<~?pbV+ail|gM$N5G+LrkymW zANSt{3l=SWP?i8V@H=24@_$@Q{)O_ErDQD&Snl?r^*m9bs=493F%BJ70Y}Y*f|19B z@rz3Rh4HM?$S5Jv=9CrZTNnmI9LCp;Z_M4K4IUYf!FRstIK^}1p6xh!;q&$K0^Ln5 z0bC>`CAc%jgvgY7u;_>gqmIbX9vc4;Pge~(9)`d$b%kO>BNU5V8@lvfL$VDkIL%RM z4s)|x`>L)Cvrs{`7G0UKfFoFMl@?u=kv>6y$Ly4^FwK(ROP|n+WMdf;tm1<5M4Ljp zDD!7%G)#F0=Ah5qrOy#rK3fZ>L%4U%A`{2#G1^0~d0s`G#YI{3=qQ=V>6n4khSUIp z?zHHVn!&2brtFJP)+5DrU#yx5WLUHYe;$>Lie$XLXzMb*EM#xaiL}mV2_}EZhn@1*itZ2 zO$KC33XmfO#T)~^MN)azM;$}D+~L)QLfSn}q5tI*yrb!K-OU1dRXd3wMoR)_Ww$O3 zDIBRdfV)l_#piEnw?uZXeBhk-r6GG4tWmAF(1A-E%*zY4P%o90otT0}ycDj&s#H~v z%6cOUAIum0GrU^AL1j)#f%zc8%`q~?5!2q%CaF-fs5j((W(L+5_EVNJf1+Par5bgV0l-lZJ3Awcb6jm8?x(#0-)dk(g#^qhnxKD?M?&NA4Wx zH!&To%UO7%xo6E-7SPZ@h=Y-F4p8?~7(@<4Zozv^Y|3bYO2S?#Z6TQikU)^ZXuCvl#J{CJ4}sGGHi$fI1T~;8romx<^Ow22k0Ie{KW!N zkhYxzEODJRyI5->&4Q1bYIg3j7s4qI07(cbLzXI2h?P?HSnp}{$Q!5*^565>1HkVv zklpbZfpMF41e~Ysm8_U2mrXaodALFDCc`2-w4eGF{MO4&Kf=u{A5@u7h9fGfJ;WKX zxrhH^zt51UxqJHPzU;gvjuW_H3S%++oj0HnH;{kUsATnz@}Ia>L_*hmLjg2R{$qTY z@3?%t`&pfIn_=9We7p7p@607+R{`)aOB&?Gnmn#Qr#s&coh-kS=wjzXcZ36w@!moZ z`(WSv>sIkV@`3-Hk-r_aCZB6$GiF)96|hIxT>QqqHNr^Htlc^Qrkb18b@k{>8UCIm z8}${Ea#(UixtO)$UpiccLM~G4?N?8BlXhW-;rTiCQ>x;bu7xm^ntD493_686wO4DX zE*chE(ysJHOC_#?KC!NHX8P8{kYagvDY*5!TR41|T;3Afj?Zj01EacjSAi z&HezW4RPbwap+rAP8w6t2AM4g#~gB7Go&Y>TOHgbX*Zg1YK81%lrhSTAKrSCFTuSj zFcXU6hEdQ8SY)3PaB3s|8GrPW(D2#(X5mg+lH$2#A24J-(CZQJD^gDrF${?YyRFxA z+x=11yTV!AH$VR7I|ESD75WZHqya$N_kSjnlbNm2f6tqvl(iKB0}mgax)(il;6Q>v z0ay)E@wuW#wFadE*x6*HaB0m^Rp$iikws%R+6bogH{$l&UTj-u5rLt}`|r=h?}Qy@ zJV(-jvD7l;367K5PhL5uTOV%|y4BybglQrdQYF~3PxnEDBXaK^4e4_uhAuj*Zn1Fpc{|CmJ%R?a zrR1FPopMMvmAB*_rMoycZde6jq?K0fT(q%rLH56Ed5lG0oD^9%1A7;G&y}ITR39pV zRu!(EYa0$Rj_OpovuEg3;g54qU2vlIjaK4~Q#afLOJq9%gN&g#82dH}p`MXSnz)X( zJ_xx=``AzlwpAMKnH~|9XB1g`I0Ew(v}ztNK1U9UKG3E!N9o*HkV!k-pGRA#H~dWP z_#vbIvm8t3)2Qr5Y1Q^x(5PXxwkl3()wR0VN)zIke50@N!eKE_y}?-l6UU;Dt&;x4 zH|DWZ)lthoD#p!XQuGZ|< z;Jb{7Q(B)qf9D;vp>&_35zBrJ-e7RBw3T_Y{{?-v`E#;tXJ2D*%ryhDb{_^3)?iv@ zUm(EFb=qZ;B28NYYqW%(fqfzRr!1?ur6jp635!zPLwS_n4|*3g3UeLi%ftKK;*{j3 z`wkwgh1AFu2PRyuAxn?*wB(-!2a=kZGR|+WhI-E^k)LCX)450(M)xO;h8g#*EI*8% zsWFTtkK}0noVa=j4j5tP3awH?Z_O8x3VFRq_#L977`> zU2vqMr=~HmH{qk)ZEE_G`t)yRCRk&QKpbiAG}H#UvabYEKXblE_LlgjRUGpQe&Lb8 zS}&}*F^KLaLb2RSwBaN^+_TLoko>vM^0td3VJoGWf!-MI37wZFb)5y~AbXv;HiLV0@3Z1+Z}_ znoQR{V7d2!^&w4Re@E3%aT_3!t&po$kdO%*vEgEIU9!VK3hFyt*I7lgm6CT3W7KwQ zNlU`P41PA(ySoPEb|$l^t&gKjVv-D8jCWU8nMeEnKpe+p*=z5ZY{}-lu76FLM3~w{ zt#2xQ$?kuODUJ5{j3~>d)hETb7cxgh&Gbk30xHR0zu6X|Pl(S~mOnRdto+Ss?vhB3 z*@gO&)oPaf?bf9`-q+CHFc;Ox!IJzVuTHeXbky5RlBea^_B>*h)76F2QkDT^z@x7! zoJCLti4$|H0u&rkSOCv8Ad~>1fTc|~fx~hihS+raB-Ie(bPgSsDNT1xL36J}I}bJf zhdULTs#%QlswCZ@9UPF{f|0u&9waE@>2komd@fbI54(XAT--z8dt^a&_sVA$s#36^vaBLJp5nCJ_ZP>H37u;G*drB@(1Nv!Uyv!LFZYWcYzzlJF(j zAq8|4{%+8-WU(4T4|9c3O{L6{dyK-8R0#$B!iu^(lHS3Oc&(2>=}-AkiAFwPKJ$V| z7qLPN;>1>QPFI7Ru8K~sNly6OJI2B0EMt~R-jZ$6*b-#+;!%-1M6;>a-#`C_aPp62 z*3fA@76T;m9H1Efwb=bH$t-RBk7_7n>}cpj!Q6cpxd#Fls#$zGFumR!*{dy}Xm7qk)Rx?)T`m zQq>xKQH5EUeo{P3=rOz% zF)~B4K5?$BC*O#!i+FTc*w{nvpkm%G^9)C#Xo7zn@|l{9@F5k6Svjjc-3|Ic=>sus zO;s!ZdBI;^{&fW%YmtR}0l^eHZeqP0leBJNvP_-od^YK3Ur|S|rRL2fff*0#c&#YI zcY^>OSv&?j)N#%o?vaFhVj7}Ub7s=&MJfVud%=CI%MQcCRiP!^7!*H$J)vVaXok>ZCao&rkA5O^VBTy{{m8>Lv(g zYJW}fN0QS%110^nuJ_>BG($K8F213}@A4Hh7ng)xHr9{wgx(k0z(|RKdNwddyeq}> zmFl$ux;VZshN|0yxd}E_h#aSYG+E9he)<&huL7^09JK@@{(eb$e>ZE5=dW_$Rh5Ujye`4kvubnU#z~+1D9eDN5FRd?h*4u%{-Cd zonUeKkJy(}$@ZBOpa%o0MFc1{bh<#q>)*mISLVmF`@A?N29Si5{W9|@I@(E zK3Q1L5JElOE1?|uIwzK-Vh04a56i|JW5zB+9^n(cYF<@V4B+P=SRZ?_c^nEX8+UYH zXs-Fn=HwIe`-|WKx&FTTc;7CtDnK!Yli-UDFCW&@Y^Zg1Lvtvn?AXw8owTij>6=aTTtI&7c;Q$ z89i;;dOp%v+dJUwnF>BS>}I_wQ`>#T&+lIe7an-Ll`b1!f8)6`Iga-R0onl)4VnJ@lZ9L68Q zhIMK`Xu@VapwFUmadB0nx(v0!!knd2nkFw06y=&i1z;0dxnR&RuX47aVyP)i^I@`S z@@Iq>A{BppJmY2R>-lr(eC}(l1-n~ofE9deP}To>x!JQDicZjF3g_sQ-kAYKi|D_MAvVkF4 z9(HAf@$L@)Hx+oiZdU%+-xzpEeJ%|5VfrEAKJdy|2q`Y%`YGF8iZJlyZv9ak%Lzdp z{v-KRcz3^1Vm#&i$d%ryq2H9aPkOYt32i>tql&NV5#FIuyOii_8*>Ybs$6a~CdVdq zW}6qgDoWM;6w37~_>iIpKz7_D2@G$ePXAV~d6S3BN@I z*TE%We?K`%0*lbA{UR>*emcdVIE=N(w0qO^d5z2OQUwm8RQcVMEJfv|iv>HgBkZL; z;>4HAQF%e%+^rP35wukCkCVBT-X(h4^uf)|}Y@T1Dr`OUbQ%V2Ooh?s6K9O4J+REb)? z-b5|7`N))mV(M>k_IQTk-?c`Gptau&=GiAPCC<~$m}|uSEK)Sbc&z8>ghoh8h|&x&iRLpvU#lg!QsoqflruXU&meji?6|5G?SjE}p|k1q zOJaTg`k>NTycPxUc$CkVuE}wxuT5(`q$@uCKl&X?3`QM@M~i}Ov}_3-QtSMWiIPcR zeFx64RCc&wO}C|B8`vfLu%9ys2+G-RlEa%=+5=o!sCyJ(S=0)4?n)Nrg21q3`cAB3 zi1`<2?@lul97IMx%S$sCcKZZQnx}vRCg!{Ck9$%bMJyYEq*0x!nW2 z5XKj;b-jjJsik!~%{SFe<>gM(gJbOEmhWx|^!fsXdrm&Zh~^JrMR#?WwmS|z$FRdZ z@;&6(78Okh&KDHZtpHTL)PAqGaTDqSqvDYd(44a89B|%uX5k)5s3IKNm0`lWgB}CM zcGB5O(F&wUHDYJiSv{K=uZa>|Ked2PdFI2KOtNG(a+^NJPE%}+WMM?Y zg2q{4xdh=jF)?^Mo@l}@uWNbI@knt~HJ-|OH|PaA)u^FD@<#m9TKG;EjA% z?&C}K8n z*mXkR;YbXa^=|3;VB%&_Nkcm5R(TrG|+0SlPIg-EFZX8N>L(9}-K z;0m|pPP;&v~FNtN++xPQ@#+T^Zjk~PJmnv@6Y)9y9 znkmN#ZzQHs_J^JZOdEy!ZMZkDkQfozpAGuL@KuOM2k~T|`!?dH0T5>cj6Lrc@-QI2vfiY90_Kxp}Jr<~{oXt++`B7G@|rgU&Kxz`uC)fc(d#|K<{F>r@aC@CW<%?$cN zef`SIRA+*2Z;1{tG7$-oc|@OuV8TjorpwD!ETvo1mbP;xG(CXZSK%CcUq+Kceu^!WP~F zY~i$>jxz2;Cik6bm2`vJ0n?#DrPpdNjh_?y{jn*+Z9+KKguK51-G>AACU@?Nc-@r#-GtEY2?tWI&drBConR!4 z4ZC@5b}izTR{d#Y+)1mR7U9ihmuU+;_>fzJFTBREpxTH#=XJ2Q^KkR$83<`*uFRgV z+PV-8WZsfIx{nsTx3AQK`j(0c+fOa6QlLTzxppKetxa&DSq*$zPcTfJbPp#eJ_S#H zV+c7D^h~j2ZJ=ovLZ<-R!^MiCcTf2|KOe{&|Fh-SIfaM$H;nh zPpXdfVx_wyN=lhDAk38{p_nF>qB)f#+r6dPwg14Bnod^$l!;CjpYnxcZ0vo(Oo)pBgBh=L1hN>w^6qExgO_5l^bd zQI(mAUsOqV59|z>gXI{=deC*XU>vnME?tpYpVQfqs>d&?3^9(RzUE8UAucq&rq$cF z`z&r*g(tAL?m0MHMq2FvZYOI?XW#8L?c5j7dI&s8bh-K<6o#z{)0lC8TII+H__MLr z_bZv6q>4o%GEYT@m9bUtqUVox6RcDLF0L#n%Esa(NjK9b&q853^FRqJ@UU=`+CfMS8eIHw@xj)9{ zU$HV@p@UwTXm|+;5>>JF;TghboOyb;bcIp7vMMIVbTZ0T)D`eVS3sC@fv?1&K-a#*vL89y19$#+Zb8>^C};uqUj1y7yB%d zW}4Ig9jib}ZEGcA>+ACX=-0=yNJtnzsvu`DL*5>Y zPPH)VWcW@d#$?2ff4Dqu1IE0a{CILO1A}S5zDfWM%#iawJ>feC6&Z^bl7MPoA{;z1 zmKUr$Y>G3A+&rS5MjtA!s=f3;WcV3WS!RX5n#XLb0jc)b80lMp|K33~#WbTK`$jJnA zcah3g`=LKtN3B`6#YNOHxmHpQg>(5G-o+x5kwr4ju1yd1F^~1mt`urnw;cw0?me*w zGHXzcu8j}4wrA(RH8?louu9BOcuw79?4){j1`jw?#!qjA(t}Zi6nv7O77B5vF4MBH z{y>8)rdmQTzegUxse_50OZJM<@1UTb!+fBe+b>OmMqiP7n)*X-ozXlmnaD6Is{;R~ z0sj5FRbH!T8Te8(*F|e=*6C7X_wjcvxL*J7%EOTlXTN85b~f0U+06`d z?D!z?^m>&d6)Q;(N4S?bdpL5Qb-5Rhy-gyXa5hd)c#b@q0!s@z#)vxc3pLpZKRlkLq<}(Mp!LX2+#D0Rzit4%`X#}^RA$d28&+v0A-ja)PP))5&VK1ImP_D9vw3Sm|Z(q-fYz@{5$OFzazBXKBP+GAwVlzP|2HCoMO8Fw(xjo)@^rZWIVPo>B|V zU2THbiFcz@$lk9zfU{+gy}iz6p_}#$`en5au9OxyM>!-}f&fO?63fjikhW-yC6EVT zHdQa7$Q22zC~HxA0*621k|U?z^tiLE9|fk$R6HI~g=%qU4$;TkelK%Tm?Uf#&pz=< zknyF(@V;-0{|nJQ^rHn$LwzgB2CK%m(CoYXZ{9*P5U-mgn1FF~X_$2wZy_SDYMY!M z6s2DBt0RgB+dhskwhVu0-T}`>9mTB)_F3>oIi?{<@$@T^%n}4t`a^KYu6>*MMnX7+ zz9_##Jyyox#-oqKy~v&@fswMN#CU<`Id*J#6v?(|vnYck+a#h#mTWU~s;H&TR^+Pg zBIYl!GkBjMmm0q~t1%h%MxRo8LCj=fM8_DbI#6iA^+F<)}YICt5)EsJ3SAYRxddv7KP8_JM;tB*$#j!G9P?c z_vuKCZEz^YwIZKZM)}BW)r9-tMn=Mm+o?Svnbm_t7wM-Jt$}P1n>D#?$3t3xH=3N2A>2WM)<`K;xUrl!Jfd0T?mTk2YWw*7w`HAgOU&^d{%^YhCr-t{ zJ+nUz2(mx7P6RCsjV<(v8UEQhDF*!4V*&m=z`J|jb?zw^YgSc);@6qWrP6b~W+mX0 zgb=+PN9cojwOy3(Qsh{v$~{k1@)Gn?D6pB5-HQ!ZZdGZ#diIs@!}e~nXI8g zdojju6(P1vhsaw2+qg(Yxdw1c-$)Y^B8Jf8mfjLh2~E>NuM#7Mb3B;%e9Cz&w_Ac` z|NW=Ws)@JtT9jMe;h+dof)wd}JV^X}5$Y#bOSV%JOYImM#NexV*S2T!N!_;i!O{9A z;{4lZuPxX$ANLgE;l|ZYA^Q%F>!}^&<-%Tm;T`@G5#^3-?=x8f!%Z`k`3wV}PhOsv z4XsW&!^BoTz3=PXNv%nJzyK`)#oPysBFDCk`4zHd>7jUPQ0iIBS9T&f@V|J%kZ$TUF=|eI7LvvHZAh7 z7@}cixMdGFLt}}-uZfQm_Atw{I@78o(ubI9cwavu^QQi?$)@bXU(W=h1tzB_w}$S^ z*rO(3F!*jt#O*q81x@x-0J+1ijNTr(fo}iYIIYaUn~ih7a_z_fdjunm&-!KjpJ$L)V6zeksVor~86Y7}&x3hzuH%IT6l@@p% zBVLy*B0(BqH>Qv9LK@Lt(?8?Q@T4WcXv9qOOs@eu*1ZfAvWy$%JTAq$W_||h(k6XN zdgd9|=h^L(YJ8junkaUwAa*Oc7dv`8>}qpSEA#AT%qCp}7$IWjL+Q1?o9HLz{;d{;7tS?2kXgl^h>Y zZ?qDSw<_rLsWF;YtFIYxJ$**CfjI4;;pM}nx#GLJjs~jH3=iJ$8l!JREHth=(&R!0 zs-m`YsH!Y_TkmufWB?^x9VeoXk$0-^nv!enLT6#ZrdB9KnHD(oiq<_z}-6Mk#RVta+o=qrD_Xl%ZS!_Exkbaiox4nq_Ll0_NFewaX(j69@K2Nc($!?3#2AmhRJP$&lX$15zwlO2(beU^nQ5YQOgi(eF3_$8q z8GwDr&`QcV!036WHL`mMr6Rp7r1v7{m0wCixR!AKGG|%;lK%w`!?Yn{0S+q*nf64b z_QrtWGy6@5%4&#a^}6;-OG5t{aZ=+ne5is=3B(CO54x}gENF{pm_8bU6lD%XDHoT} zthq=nG^2S#ktSI==DL9Vd?Tt62eA5t@x&B47d1TdIQc!AK^Yb)^)-kwgn*vmrU z=tBw_Gl8%y6N!W-tI$@a3>i^9gmn>8xua^K5~L2#(%IET-!i(%RC&jJr8bT<$rgh3 z7B19`_w2hhwdS|YWGLYnvkw!9Cysl{sXz;T7K;C<_cp0Un1v&dRXaVJF-m4NYG4SDwf2&=$fSjB`LmIC_GX9h-L_@E1tq<|!t#Xxy zM6WA`r2T_-*YTt)sOI`lb5zU)k3*A&H5tv{3b2yP8@bz;XVOXga8~VUdE=N)toBg! zwalSyaAs%PVUo3Ex3`IHlKnZ zNPRK$ZWa?H@`cMAu*;7*92v_GRa6O;(EAvPG9B7h1&Z4&*vg#W#AjSd9%yV6V{Awu zW-WKF`Qj-1_z9Qm6AI<3ZL$)7JQy_RC|x!Po!V~je!5kebZRu0aYSk{@m_L$z>Ovm zCm=JSQ_b#eekuP;Dm$6JXRTb1l_;M2%Yd}aQxKs_<-F5geyl$Ec=Ez!ci5Tg={C+P z_HZzTU=6OOb#f!5#AoxoeGbcYT%%e0-IZjHJsmGb$9~!DBa4O1qfj^0v7(WW1W~73 zZcLvtj-Vl4v2c9qZ7yo?3gF;wWq>A!=R_ZIOqFuoGzeYha12hV5Hj^z;ePwnQ37m> zS%ja1yW?rk@ij+s+N?cK^J^yVp*i|@CRLrVEvQw7CX%3YUQ3CL0;62EA>Swge~XDnkRj1``A2rH+L3Ug%nRaxk;#W^BC9v z+R+QrjtDf0^Wv2R{82X1)jO$HV~iGTIe2gc_dO@jcN<&C+Y&*qN;?Ad?RJTn#$JDX zjJ!pUz|LGC#llo*8dRYkR`Vb=uYV>Po6c6`=mPWI#*rd2(duj$t%RS{S2<(3+>T6f zTx$rMvZ2c>xkTo$>R0LIdUN6Y3J0*A7iurEUu|_F^HRd&e`$;9e($-~galldjjft=+6+P|k#D3PO6Pa7XW~;& zH`2<3RT~TcWGOPs%}`EM_v=P~QKeLCrzexa7kmLWRAmEs4mx{V~QG5|&^N{?!H5S^#qn zY;q&8ztd^1TMuQcudKA9xX@f!%^N)vjQy=DSlcxtWfK$FX@WuMtNp;!^d^BEsu&Qd z-H>6cp7!%GL8b8EYUGFjv8)$5%r80k=J;ietdT_2_$6wzc7VVJ4|SR2-*@iofv1!g z72pz85ORI+~ zIl>#Iw%L>YGqH15mWIX$O$#8FmOdJ@Wf`ao+MpLxcq?`a2#PDwBAd0ZO9D=OV?*#O6fI-XMN>x=r|M>PZSPt(BWpWzX4-M?2eiH zvMd+ZDrfDS;J^W#g?1{}qO{UTc|4Sq1(~SZiA0d>(|b$Xn8sFVy~+!Eb5+ zX2)5C>;rfRi--!89!t=e>?f`pQv~iy~7wp;-N-vdA4<+XT$juMA zJ{-a#wgJoz^y|4X3yf443-CRzuxiGX4Q~oyx=yV9=PvdlYanHItHZC{uNK)12t_r$ zIa-fa?J=eXoKx0><`GlU367J*T5vtoAhvgl_5a_SlxNAkgz z=-ma{tIE%Us^sPVTB^r{H0Y#_5~+E`YA)8VOQN;7#Km7Eq^9+TPr1hyyo~%Rzre3D zY>HgOFHcmck)c9>L^ygvK^ee?Ikn3pNK@-0V~CFM)MAXUhq3#0w^M?O02WJOGmPQ3 z0?Ua12Bm_e4Sh{>8^o=o_gM~TdxDo4&y#$=j*~KHmTOp_OQyVZX(Ce|@C>ftGLHvd z4@TBE5R$Xu9m0A2!mpS&NTcht>KA<^JK+@{OM4gb`l~;6xI(y@hka?FldUI1=ivGF zCYlG{24Asdxm+*H91~?_?aKAbg|u$d`+c}Wb)R>v#`sekwv>o(Ct=X$@J*`UUWV9g zRVb!=v}No-LEK{2aZs*KGYL7LuJl$2_u86gq0@rDiAx$OC0Mc@;gxPVAWZQ<&Mf^r z5ZBy5_sWru$hAqwR=EavGYbLxKI(P0B$xe8(JH04m6U@dzoc|aC9baxb0?+_?d zJt0!7DQU2{?es2Jv6np+$vVrUwFW}i;UV5zBaQoD9BFwT8TVFw;2}9)7waiw?^7gyMwhOw$HIt)l24~5 z`@vFBWsEqpf4q&ol{O;y0H*}8EXnS)*_KDOha?PnQqOcwPgpq$QCnBWmn95Y8@vs< z6K20uwbNsQ(Sb!ct~KrCV$z~prC#RU>65BQYNjkG9`s#rLe2SWQT!DnQr9zO2XYuw z_{E*^Sgby>R#FcQPgJKDnokueB3S3MuA*`EF%^z8Za;p^IM>VM9(vO%hO>xlKAKZL zlQr3A8RdjrR3Eu^fKsq(5@dz=((e;uL&)U5tZE;!YS#(TOx6bh_yp6arW?;;(ndJv zi;)T*Iu{&OLgrY{)o~Pe{`AvCzZt3*!eOTCS;oq$7<^r6myj06h&2cxk|Jp?PjLeqE8v-n9pq_+lpS>ooGxjpFgp!pmq&>ZsQW2qg?Z>=|uL8 z?G^Wdn4U?{G^NgLhEI{!<&QpBukq>)d14)PGzRytwWO{uwBDqf6t8}=q`bYULfffN z_uEmhSnHd4Z312Wh*)x0)<4N4W_B%htfr`&x@LezX?3BP^#a>8DpebmBCL3=#+HtpL_)QqMq*EUaT&W6j8;FaoIM%Am7Z7GtpmM_KWEb zRo3^$nKm2yju1zpSkgOtFqiv|zO5yz_LtRYLbld%^g*gG;jO}PASN}<_G?$Qu#c0o z3ZE~eIY?$|vYD->iDA}gzWoXjLqK??h?Ge{)R_1Qv5?dsspW=8wO@24$-|`W++}bk z`ejH4S(hTO+jy2u7{>etWsI$xd?12b9LK_QaqQ$g$&I{FDfudea#KEI^}5L@`C%VKv0b2%&};PT#+!tIPs0c=TGNloe?vBa4y3fBB5=?N z1}zE?Ohrt|Un*j!ql;(yU*K?o7ja>%yiTbkS3{U55fdwnup}v#DDc%p)pr1)q zDTT@lbWnOgM`htA6U zKOU208Wmky#jS6N6MdFCg@PX9dF_=0VJZ~~ybDJv>O(veowHr z!ixbX(%P5(mbr`;s^!JH6$^PY=n<)8N)qT0IgA0t*{_V|=ZX{10=P0dCestbLBmwu z$V4)-SoW7m^amqYt8#-Fj)PnAXgqnZUR5yo64cYFn)so}M@~{1!-CiZ( zWX8mDDxqS%@j|nDt>)=cRwLM4cE!!{b(nr%Cg{#`knXnjT2kwxNe;m=$QTqJck=LAkEk$LjEWjO7!GUdfABP2!?qix; zXZ=E;duBgEj3D4t)SjVl-uJ(xO!+TzKm zT-)qIem%?VhPvZ)_9Mxf?U*G=ta*mL_55D(#b`%ao79|i*3&O_0fKwlBhFE}_LfBg z&XKFJx(@uycJTF5)-$N@ABVXTVP-XJ`Ek@N+0iQdG`P5$$mbD(#kIj&?p!=TKIW|6 z9WR{3Tc3fpX&JJLcO`n2X`ghoJls zatJjHqn&;`S3_5BeJD*?gwH<6^33Hz8RqA+Q{I5a9y~lt(|zTU{EmDP`I?%$1--y2 z1S@3;Vo0xcEcy9hpE3A$isSsIKDk z&4wC2*j=Zbv30yrXsP=cF(SjNleLaU z8`Mv-Uboq?mig026Z_Rz9$Egkigq4F2D~zDw|R@XCVQR}`<^D}w;*R8ie8TUwtlM^ ze9T(1E!U&XwND1&5s**pDQqksFFnu+T(S#vx>{1uOeOHwyy7bg2eA|jXUlqqn1clu zs1)R+W{{^}PCx=$6eG)T097XC-UntR_vsL1W}=4B>%mDfS~KZMF+!TSSWlijCL^bp zMU@J!0G-BxIHGf$>WBV=KJ^d%M}7JpwR3bw*YBFc{rtyagM?5=z(?fmxEQUz8WB^( zk2Laf;c0Nh28B_7c>{Rf0lOY)EVnYDMn>)*;xR9eC0hKrkbRvmz+CMpNoDznQ)E`S zwMUP3CS{-8TTy>+g)gQ&^PtjKmE{r>yZ#b-#$}e%V$;kNe`A(3oR&}9l`B@lPdC41 zzgxLoQWzWkTs5QIs6gR!i6%4oeq~nxQBZ;r^(d!=@5j2?WHQ7{sxf(6+a3pA)vn{2^CZQ;Hr2PVTo)OLDStgR!v|jJJ?!Aha9YRoB z$Ik3s;3s~+Pxz?V;xZta3K3%{I+U>pg3unEaAmxX6c zD{%Z<2{MrRnq6sovG}xME;*B!1rY*v3L!%yn)_p~I=jyo>vw&8PziYH1yiAt2P!+jh|w!z*Zx`ZF7+(*2elpjd@(b=3% zu4K~TxOqdQee|IBENTeXPz#bp4|zNP5^%ea^LQdbe1LjfX(hs?E5l9kP)N5e;?=mO zgeC&+>0qCa z)ecjT(WRhtxJyx&I@Rnj#k{nMd{giWGzMj+*moJ03`K%HB|^l^+gsP?B?iptSRoYdiyg~xq4!NpMA`mOcY&C55;iMX(!G+e#s? z&9<`d#c(v0b!W8xyN}VU@5bBr7NzP&qC;5&qP`lD$tiX#_!lu}iz+6ZBVLidbcQRS ziGcZ35@OLi@h*|2CE7qmS1hT?#wcJ@H~R1c(vY+JAin-8bt z^s}6OmMS+D#33r7S+q>-iQ#l9%NE)k2ssY@sK7VN9&)VWae=U0z(NqGJ3~bLJHZm| zrQQ=fxw`CtoPqgI^qpeJqVc0t?jgq{Ic8{y+8SXm8V}?R-Kbf2!ZYCegFEDoPV?qT zm_yY~msGe6ds#Q1>OU)C(tlC%bQQ{&MW54tXf>>Imqlk5QL+}fzfcepdZxp`AZgs8 z3ZZ3`HclI4_Jr{@8*RL|W^G0wwzb^k%UKNDxBTmFL$B)yp7snBg>y7Dh{DfQs2y!# zS34iH^JKjcB(I%W%f6DjkG}XCNn&l7LI?Z*M^!MmifQdLo-a%7JFiH$ycR59Jm!795+GNtE3oYs}mmHWHl<=(^}LUVW4-()QoTcNKq!$Ib}o%>uam1 zg7PtwaX>+ei;Ut2BaXm1b23iDjZ}(`NEt^%e#Kda3Lec&x$*g_dI~vVrpu>i=GfhH z6fICGDUrciEb#5>%=!^`9-(u-(?-Qsn9Bc+SJ{Ps+wOSxpa~Dk^mk25dg?)Wr5v{p6h3$fJ_#P_I z=6G{p_2bY;CCEN#$Ub&6Xgf?cZR+Y&+g?n`q(7>aWZL-rj1$6c)c$*`Yh?KW- zH`Mq=8EAj|7hlQuoS2jQ7T4LHalLAHWr=*x!ePjU&srKCa5fVZ0gQdri$2*FH z0z)VwhfTp{6mVOej~&-r%-h~@?k_*MGWX@_t_7VUrp%t3ocN-*_+ZW${tQf%l9;BX ziU4jg)oZG;y7L4R;`t-iwA_m4h`A5vZiwMvv{Rlf!ah3qJhnge2x(7EjfuqQwF4;4 zB4IG!Oe=9HN=knQhiTr6j!7}NQ3=*FPOwTgu$qrx^)S{L*6%Ch(XLcqEI)`wIZ9)V zHblvRpaQRU!Y9_Qri^v6c^yJA|LKd#;oDY(-WPK_FWpc`d<-;W_K3y&lH0^sk|@qi zqgk-iDfzbvJ{uq6wCo5~QS%1EC06$49kQl07ZI%w#k%Ijzi7i8mm!Optd`Z%*NutW zGCqv?nwR#hcBrDTM{YMkR))&Jsv+3N^I<_gT*MUGdu++~(1iyCcAtUML;;%=`00*r z(PCGRJFeM^op~*}(k2{GJ058BScZ<)>C1O>pVPP;6}O)g6b$4NJ4CzGEDJiKo=K`E zI4;*1L)EN3r^@jn%t4WzW>fa(@wvi*y3R=2EGrdhSv)!qHzVt4;83 zbnwd9c%6Rhc%zj+qbU)^u?6@%V7uwsY ze@5fDD170GMBenjnqEI7!w%~TqTtUnATP!Xk1 zv9~B1iW~8T&Z3~VatDI>%W0tqF0C|rxga8YqwJ=YpgmhtC{a>@syNvW>y)2VhA(y>8modn zSH_lwX7?Cn@iRy zULF5ShOL9K5FM0v?1~k+IrtIo!eFPJL|Rcd-iL8R78@6{0Iuu~{#j zu)Y1`IC?!Og28kz0y#n-_K?YoC85moVImI!5-(&}LQ+x-eTX-r6uX9>!fDwVk|lXW zbzYMV3d80cL0K$Vl8H0@A}{(BY5i5{q?yNfpCR2t`eV5pf(SjTV+16 zmtH1QFt4zr4!mJg(Fwp6;Zto0OqpgbV)S+`aE~qsv4Z6|z^z<%rQSB1W5*UY_{`I9 zW@cY-wv~ZEtv7MxALbt|T%@XYBpN+6yrtyo!0qevBGhoox`+phW2-Dfm)~SDf_=Y- z>k;FoV&5wB9vB%b942rCD<^0p;UkSMwI1ks25!gBBloDh#Xhfz&kSndsb!q)wdrHh zndwRM+8f9G6V$w6Yd5YhZC0*kF)_1!`~!Tug^9+-bo!TS6ie*R_n8#%sxIRD zWNjr1-vxE7iDO;>N7dgA>YH?(i0e-;AKIRB#xA8~5lWZgsF*cnf`cfda=e<5kD0DN zw~OkUU!ggRb;Wx=zhtv_XrQSZBkgEws(!3j!Pk*anRwJ4+miGoph zp*7n2z-UItM+w=gqI~I*P976e%)&*6;-!vrs(C3irt7)31f}w7)ft0SYN|G_}J zYBflJOgG#_K@#YzQjj;UK{8ZZ&`fxt73QR!?;J+6+^v9fgt?j5)SEo1al0G=yO;38 z^VYC-K)|Y+f%N)CFgr&Luz8H5QFF%)iw2PS`M76i*$sA_ICaSwY4z(U8y+-t^O6td z2Y{b$fuFeP=4k_VW8sHGUxLklu-|Z)wu67OnD~NYWDUJv04l%LI1A2PR&GOckV>(J zNO1_V9qYEL<8XOz^aD>M-3Azpia8KG4p!Y(;@ZsGgDEX8sUnVhy6f4H1@M1L)*ZB&(wW+Fz;TQQ6 z_ABltEFzP+ia4sdicjgYm8ld|1e5g1wsFc5dzunRJQ0)5&`-lnM|v_>MD-6iD zo%mZyyd^ocNx;eRu=#|Nlk% z`db#jBm8e!KK;m|YiVu{+^?{u`~S}i51i7y8(i#fd4c;KzkTl0A9=sK<@$?)fd#4G zGHU(E`1>7^pSl0hv4>AceKb%`Wgz?+5Ul=Z%JL5Tk^8x}tv)OBKMPsEr2Z#+MC*#b zJ@7^)z-!Alk54~RmbVNb%l}HuuWe?g1H>8PH#63^u={ZY`98=_z>Z=8C^ysNe*zW# z0^I^){Q>l6dAOVsaxtNR6VV7DAhTrLSNU;*wW(9D5PV2f_$K8 z27t|y-9Z@N z>|~(bfhqzEiT{&NP}j)vA6@-hu5XC&2A;z~0I>!%FpN8hFv{N$|48#Eb$^5KVb{IN z0Q6)F=;>S*2Jw{8#T@W^TPtR zb%3MGKU0>s0mpa5ckTW;|0{bvkOH6#+<@@`7W^{-<|}$PKd?XapVj?MBN5w=NWKE4 z_`(1J0@&csl;v%sc$f5#QvNJYAVdT04v;q-Fq|hp8Q<(L)9g=_zgx@KnY>)P@EGa~<4ru+zV)UQCnascCf@`DDvW_io!{R?PgqwV}x zng|?`<$IvgG=U!cUd5H)r+pjx{uB01=d(H=Ob-B2^Z-k^JAC?7{R{TDGSZyKTap77 zkOx=*&_sTwEbpS~e}gOlt=a1WKBxXuxNpWTTnRri0+cihC@Jwz;y1lL24+wH8zXdo z%!Ga#=wFG&H#gFKK-HQ8J^qtBM5^Zd#Q!!(|$zq`71C+ z;wh9ZP}o*LJivti`!K+3tEJ7~&3N)Q#H<-;6i7g$Ai0BcTfL9_b#dsg60$y{#c~GPehkp| z>F*#tckd(RjO^|7EFCTGOr8EpUwZf2xEg3C!@wty-JuHsE$DyN_%m=XpPruaw@#eT z%F4`GSNp&F^Dh?bPvHSzKA>2lJ5au(`_Sk11_t^z_d-GaKFoY;GoNkSdwc;2-5rKu8UriI1vnxFBy>U?g;+k^gd3|!ruHpCTj8e@44jx-O&Ol zV2=1RWqAjl{|WOwG##-hFlDm&El|h((o$5dbs+*wIH1Pw_Bte&f8$Cze-rl4MdpT< zYC!~KEd`#tjmF{XFU&u~q%$2NBLI*;Amm*Eo3H-`bJ8}qGSmM*ZRYTG7AqXk2m^rW z$djL{{MIeT-2MmiFDl&UihPU;NZ1KHciZ7S6zDyJ`Ccve!&Kg{m9ZlfBoYAk9(eBd z+e|S3fmAZKGy2W*`F$dyU08Q8P}DBq0X&HPOj+KEu=k07n~*+S2w~I%a@zvWw?h*@ zQkM5ixPNhe%uM3q?sxkZ z(I0Z%iQjl%W7|q1s(k=a6d055S~1Im`^0Zu{|jJF^z-c6ec1gd<-gR%jeH;W_x|L5 z!0=zBtN$eZwVe0k3;zP*q2Cwnw`jxnOL#vx>n{vB<{vTtR~xt=ee)ME9{WD0Ad|DE;MaDn%E_X8vS;w6yY;k~#UCh0!sek6lm9D2HcasJY}@4JBi#o=ZA z7w30}@b?9}@BaH2D1`YBpkL0we+PY=7T@;+{0r32_8s)wlGa_X!1r1A-LU>*C2;|C;$PDjYD!_+MxFTjkuR{<#Cbf57(_bH(7_%s(9W{awg!HFW=Y-Y=k| e>7RkW|3L}~{8a%0A_e?wMF#;%aRUZYkpBmm4H6#! literal 0 HcmV?d00001 diff --git a/pyspark/pyspark-shell b/pyspark/pyspark-shell index 4ed3e6010c..e3736826e8 100755 --- a/pyspark/pyspark-shell +++ b/pyspark/pyspark-shell @@ -1,3 +1,3 @@ -#!/bin/sh +#!/usr/bin/env bash FWDIR="`dirname $0`" exec $FWDIR/run-pyspark $FWDIR/pyspark/shell.py "$@" diff --git a/pyspark/pyspark/__init__.py b/pyspark/pyspark/__init__.py index e69de29bb2..549c2d2711 100644 --- a/pyspark/pyspark/__init__.py +++ b/pyspark/pyspark/__init__.py @@ -0,0 +1,3 @@ +import sys +import os +sys.path.insert(0, os.path.join(os.environ["SPARK_HOME"], "pyspark/lib/py4j0.7.egg")) diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py index 3726bcbf17..d4a4434c05 100644 --- a/pyspark/pyspark/java_gateway.py +++ b/pyspark/pyspark/java_gateway.py @@ -1,19 +1,36 @@ -import glob import os -from py4j.java_gateway import java_import, JavaGateway +from subprocess import Popen, PIPE +from threading import Thread +from py4j.java_gateway import java_import, JavaGateway, GatewayClient SPARK_HOME = os.environ["SPARK_HOME"] -assembly_jar = glob.glob(os.path.join(SPARK_HOME, "core/target") + \ - "/spark-core-assembly-*.jar")[0] - # TODO: what if multiple assembly jars are found? - - def launch_gateway(): - gateway = JavaGateway.launch_gateway(classpath=assembly_jar, - javaopts=["-Xmx256m"], die_on_exit=True) + # Launch the Py4j gateway using Spark's run command so that we pick up the + # proper classpath and SPARK_MEM settings from spark-env.sh + command = [os.path.join(SPARK_HOME, "run"), "py4j.GatewayServer", + "--die-on-broken-pipe", "0"] + proc = Popen(command, stdout=PIPE, stdin=PIPE) + # Determine which ephemeral port the server started on: + port = int(proc.stdout.readline()) + # Create a thread to echo output from the GatewayServer, which is required + # for Java log output to show up: + class EchoOutputThread(Thread): + def __init__(self, stream): + Thread.__init__(self) + self.daemon = True + self.stream = stream + + def run(self): + while True: + line = self.stream.readline() + print line, + EchoOutputThread(proc.stdout).start() + # Connect to the gateway + gateway = JavaGateway(GatewayClient(port=port)) + # Import the classes used by PySpark java_import(gateway.jvm, "spark.api.java.*") java_import(gateway.jvm, "spark.api.python.*") java_import(gateway.jvm, "scala.Tuple2") diff --git a/pyspark/pyspark/shell.py b/pyspark/pyspark/shell.py index 7012884abc..bd39b0283f 100644 --- a/pyspark/pyspark/shell.py +++ b/pyspark/pyspark/shell.py @@ -1,7 +1,7 @@ """ An interactive shell. """ -import argparse # argparse is avaiable for Python < 2.7 through easy_install. +import optparse # I prefer argparse, but it's not included with Python < 2.7 import code import sys @@ -21,10 +21,13 @@ def main(master='local', ipython=False): if __name__ == '__main__': - parser = argparse.ArgumentParser() - parser.add_argument("master", help="Spark master host (default='local')", - nargs='?', type=str, default="local") - parser.add_argument("-i", "--ipython", help="Run IPython shell", - action="store_true") - args = parser.parse_args() - main(args.master, args.ipython) + usage = "usage: %prog [options] master" + parser = optparse.OptionParser(usage=usage) + parser.add_option("-i", "--ipython", help="Run IPython shell", + action="store_true") + (options, args) = parser.parse_args() + if len(sys.argv) > 1: + master = args[0] + else: + master = 'local' + main(master, options.ipython) diff --git a/pyspark/requirements.txt b/pyspark/requirements.txt deleted file mode 100644 index 2464ca0074..0000000000 --- a/pyspark/requirements.txt +++ /dev/null @@ -1,7 +0,0 @@ -# The Python API relies on some new features from the Py4J development branch. -# pip can't install Py4J from git because the setup.py file for the Python -# package is not at the root of the git repository. It may be possible to -# install Py4J from git once https://github.com/pypa/pip/pull/526 is merged. - -# git+git://github.com/bartdag/py4j.git@b7924aabe9c5e63f0a4d8bbd17019534c7ec014e -argparse diff --git a/pyspark/run-pyspark b/pyspark/run-pyspark index 9c5e027962..f8039b8038 100755 --- a/pyspark/run-pyspark +++ b/pyspark/run-pyspark @@ -1,4 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash # Figure out where the Scala framework is installed FWDIR="$(cd `dirname $0`; cd ../; pwd)" diff --git a/run b/run index 15db23bbe0..8fa61b086f 100755 --- a/run +++ b/run @@ -40,6 +40,7 @@ CORE_DIR="$FWDIR/core" REPL_DIR="$FWDIR/repl" EXAMPLES_DIR="$FWDIR/examples" BAGEL_DIR="$FWDIR/bagel" +PYSPARK_DIR="$FWDIR/pyspark" # Build up classpath CLASSPATH="$SPARK_CLASSPATH" @@ -61,6 +62,9 @@ for jar in `find $REPL_DIR/lib -name '*jar'`; do CLASSPATH+=":$jar" done CLASSPATH+=":$BAGEL_DIR/target/scala-$SCALA_VERSION/classes" +for jar in `find $PYSPARK_DIR/lib -name '*jar'`; do + CLASSPATH+=":$jar" +done export CLASSPATH # Needed for spark-shell # Figure out whether to run our class with java or with the scala launcher. diff --git a/run2.cmd b/run2.cmd index 097718b526..6024740726 100644 --- a/run2.cmd +++ b/run2.cmd @@ -34,6 +34,7 @@ set CORE_DIR=%FWDIR%core set REPL_DIR=%FWDIR%repl set EXAMPLES_DIR=%FWDIR%examples set BAGEL_DIR=%FWDIR%bagel +set PYSPARK_DIR=%FWDIR%pyspark rem Build up classpath set CLASSPATH=%SPARK_CLASSPATH%;%MESOS_CLASSPATH%;%FWDIR%conf;%CORE_DIR%\target\scala-%SCALA_VERSION%\classes @@ -42,6 +43,7 @@ set CLASSPATH=%CLASSPATH%;%REPL_DIR%\target\scala-%SCALA_VERSION%\classes;%EXAMP for /R "%FWDIR%\lib_managed\jars" %%j in (*.jar) do set CLASSPATH=!CLASSPATH!;%%j for /R "%FWDIR%\lib_managed\bundles" %%j in (*.jar) do set CLASSPATH=!CLASSPATH!;%%j for /R "%REPL_DIR%\lib" %%j in (*.jar) do set CLASSPATH=!CLASSPATH!;%%j +for /R "%PYSPARK_DIR%\lib" %%j in (*.jar) do set CLASSPATH=!CLASSPATH!;%%j set CLASSPATH=%CLASSPATH%;%BAGEL_DIR%\target\scala-%SCALA_VERSION%\classes rem Figure out whether to run our class with java or with the scala launcher. From fbadb1cda504b256e3d12c4ce389e723b6f2503c Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 28 Dec 2012 09:06:11 -0800 Subject: [PATCH 29/85] Mark api.python classes as private; echo Java output to stderr. --- .../spark/api/python/PythonPartitioner.scala | 2 +- .../scala/spark/api/python/PythonRDD.scala | 50 ++++++++----------- pyspark/pyspark/java_gateway.py | 3 +- 3 files changed, 24 insertions(+), 31 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonPartitioner.scala b/core/src/main/scala/spark/api/python/PythonPartitioner.scala index 606a80d1eb..2c829508e5 100644 --- a/core/src/main/scala/spark/api/python/PythonPartitioner.scala +++ b/core/src/main/scala/spark/api/python/PythonPartitioner.scala @@ -7,7 +7,7 @@ import java.util.Arrays /** * A [[spark.Partitioner]] that performs handling of byte arrays, for use by the Python API. */ -class PythonPartitioner(override val numPartitions: Int) extends Partitioner { +private[spark] class PythonPartitioner(override val numPartitions: Int) extends Partitioner { override def getPartition(key: Any): Int = { if (key == null) { diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 4f870e837a..a80a8eea45 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -3,7 +3,6 @@ package spark.api.python import java.io._ import java.util.{List => JList} -import scala.collection.Map import scala.collection.JavaConversions._ import scala.io.Source @@ -16,10 +15,26 @@ import spark.OneToOneDependency import spark.rdd.PipedRDD -trait PythonRDDBase { - def compute[T](split: Split, envVars: Map[String, String], - command: Seq[String], parent: RDD[T], pythonExec: String, - broadcastVars: java.util.List[Broadcast[Array[Byte]]]): Iterator[Array[Byte]] = { +private[spark] class PythonRDD[T: ClassManifest]( + parent: RDD[T], command: Seq[String], envVars: java.util.Map[String, String], + preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) + extends RDD[Array[Byte]](parent.context) { + + // Similar to Runtime.exec(), if we are given a single string, split it into words + // using a standard StringTokenizer (i.e. by spaces) + def this(parent: RDD[T], command: String, envVars: java.util.Map[String, String], + preservePartitoning: Boolean, pythonExec: String, + broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = + this(parent, PipedRDD.tokenize(command), envVars, preservePartitoning, pythonExec, + broadcastVars) + + override def splits = parent.splits + + override val dependencies = List(new OneToOneDependency(parent)) + + override val partitioner = if (preservePartitoning) parent.partitioner else None + + override def compute(split: Split): Iterator[Array[Byte]] = { val SPARK_HOME = new ProcessBuilder().environment().get("SPARK_HOME") val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) @@ -100,29 +115,6 @@ trait PythonRDDBase { def hasNext = _nextObj.length != 0 } } -} - -class PythonRDD[T: ClassManifest]( - parent: RDD[T], command: Seq[String], envVars: java.util.Map[String, String], - preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) - extends RDD[Array[Byte]](parent.context) with PythonRDDBase { - - // Similar to Runtime.exec(), if we are given a single string, split it into words - // using a standard StringTokenizer (i.e. by spaces) - def this(parent: RDD[T], command: String, envVars: java.util.Map[String, String], - preservePartitoning: Boolean, pythonExec: String, - broadcastVars: java.util.List[Broadcast[Array[Byte]]]) = - this(parent, PipedRDD.tokenize(command), envVars, preservePartitoning, pythonExec, - broadcastVars) - - override def splits = parent.splits - - override val dependencies = List(new OneToOneDependency(parent)) - - override val partitioner = if (preservePartitoning) parent.partitioner else None - - override def compute(split: Split): Iterator[Array[Byte]] = - compute(split, envVars.toMap, command, parent, pythonExec, broadcastVars) val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } @@ -139,7 +131,7 @@ private class PairwiseRDD(prev: RDD[Array[Byte]]) extends val asJavaPairRDD : JavaPairRDD[Array[Byte], Array[Byte]] = JavaPairRDD.fromRDD(this) } -object PythonRDD { +private[spark] object PythonRDD { /** Strips the pickle PROTO and STOP opcodes from the start and end of a pickle */ def stripPickle(arr: Array[Byte]) : Array[Byte] = { diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py index d4a4434c05..eb2a875762 100644 --- a/pyspark/pyspark/java_gateway.py +++ b/pyspark/pyspark/java_gateway.py @@ -1,4 +1,5 @@ import os +import sys from subprocess import Popen, PIPE from threading import Thread from py4j.java_gateway import java_import, JavaGateway, GatewayClient @@ -26,7 +27,7 @@ def launch_gateway(): def run(self): while True: line = self.stream.readline() - print line, + sys.stderr.write(line) EchoOutputThread(proc.stdout).start() # Connect to the gateway gateway = JavaGateway(GatewayClient(port=port)) From 7ec3595de28d53839cb3a45e940ec16f81ffdf45 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 28 Dec 2012 22:19:12 -0800 Subject: [PATCH 30/85] Fix bug (introduced by batching) in PySpark take() --- .../scala/spark/api/python/PythonRDD.scala | 2 +- pyspark/pyspark/context.py | 6 ++--- pyspark/pyspark/java_gateway.py | 2 +- pyspark/pyspark/rdd.py | 25 ++++++++++++------- 4 files changed, 21 insertions(+), 14 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index a80a8eea45..f76616a4c4 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -194,7 +194,7 @@ private[spark] object PythonRDD { JavaRDD.fromRDD(sc.sc.parallelize(objs, parallelism)) } - def writeArrayToPickleFile[T](items: Array[T], filename: String) { + def writeIteratorToPickleFile[T](items: java.util.Iterator[T], filename: String) { val file = new DataOutputStream(new FileOutputStream(filename)) for (item <- items) { writeAsPickle(item, file) diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index 988c81cd5d..b90596ecc2 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -19,8 +19,8 @@ class SparkContext(object): gateway = launch_gateway() jvm = gateway.jvm - readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile - writeArrayToPickleFile = jvm.PythonRDD.writeArrayToPickleFile + _readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile + _writeIteratorToPickleFile = jvm.PythonRDD.writeIteratorToPickleFile def __init__(self, master, jobName, sparkHome=None, pyFiles=None, environment=None, batchSize=1024): @@ -94,7 +94,7 @@ class SparkContext(object): for x in c: write_with_length(dump_pickle(x), tempFile) tempFile.close() - jrdd = self.readRDDFromPickleFile(self._jsc, tempFile.name, numSlices) + jrdd = self._readRDDFromPickleFile(self._jsc, tempFile.name, numSlices) return RDD(jrdd, self) def textFile(self, name, minSplits=None): diff --git a/pyspark/pyspark/java_gateway.py b/pyspark/pyspark/java_gateway.py index eb2a875762..2329e536cc 100644 --- a/pyspark/pyspark/java_gateway.py +++ b/pyspark/pyspark/java_gateway.py @@ -30,7 +30,7 @@ def launch_gateway(): sys.stderr.write(line) EchoOutputThread(proc.stdout).start() # Connect to the gateway - gateway = JavaGateway(GatewayClient(port=port)) + gateway = JavaGateway(GatewayClient(port=port), auto_convert=False) # Import the classes used by PySpark java_import(gateway.jvm, "spark.api.java.*") java_import(gateway.jvm, "spark.api.python.*") diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index bf32472d25..111476d274 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -152,8 +152,8 @@ class RDD(object): into a list. >>> rdd = sc.parallelize([1, 2, 3, 4], 2) - >>> rdd.glom().first() - [1, 2] + >>> sorted(rdd.glom().collect()) + [[1, 2], [3, 4]] """ def func(iterator): yield list(iterator) return self.mapPartitions(func) @@ -211,10 +211,10 @@ class RDD(object): """ Return a list that contains all of the elements in this RDD. """ - picklesInJava = self._jrdd.rdd().collect() - return list(self._collect_array_through_file(picklesInJava)) + picklesInJava = self._jrdd.collect().iterator() + return list(self._collect_iterator_through_file(picklesInJava)) - def _collect_array_through_file(self, array): + def _collect_iterator_through_file(self, iterator): # Transferring lots of data through Py4J can be slow because # socket.readline() is inefficient. Instead, we'll dump the data to a # file and read it back. @@ -224,7 +224,7 @@ class RDD(object): try: os.unlink(tempFile.name) except: pass atexit.register(clean_up_file) - self.ctx.writeArrayToPickleFile(array, tempFile.name) + self.ctx._writeIteratorToPickleFile(iterator, tempFile.name) # Read the data into Python and deserialize it: with open(tempFile.name, 'rb') as tempFile: for item in read_from_pickle_file(tempFile): @@ -325,11 +325,18 @@ class RDD(object): a lot of partitions are required. In that case, use L{collect} to get the whole RDD instead. - >>> sc.parallelize([2, 3, 4]).take(2) + >>> sc.parallelize([2, 3, 4, 5, 6]).take(2) [2, 3] + >>> sc.parallelize([2, 3, 4, 5, 6]).take(10) + [2, 3, 4, 5, 6] """ - picklesInJava = self._jrdd.rdd().take(num) - return list(self._collect_array_through_file(picklesInJava)) + items = [] + splits = self._jrdd.splits() + while len(items) < num and splits: + split = splits.pop(0) + iterator = self._jrdd.iterator(split) + items.extend(self._collect_iterator_through_file(iterator)) + return items[:num] def first(self): """ From c2b105af34f7241ac0597d9c35fbf66633a3eaf6 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Fri, 28 Dec 2012 22:51:28 -0800 Subject: [PATCH 31/85] Add documentation for Python API. --- docs/_layouts/global.html | 1 + docs/api.md | 1 + docs/index.md | 11 +-- docs/python-programming-guide.md | 74 +++++++++++++++++++++ docs/quick-start.md | 40 ++++++++++- pyspark/README | 42 ------------ pyspark/{pyspark => }/examples/kmeans.py | 0 pyspark/{pyspark => }/examples/pi.py | 0 pyspark/{pyspark => }/examples/tc.py | 0 pyspark/{pyspark => }/examples/wordcount.py | 0 pyspark/pyspark/__init__.py | 6 ++ pyspark/pyspark/examples/__init__.py | 0 12 files changed, 127 insertions(+), 48 deletions(-) create mode 100644 docs/python-programming-guide.md delete mode 100644 pyspark/README rename pyspark/{pyspark => }/examples/kmeans.py (100%) rename pyspark/{pyspark => }/examples/pi.py (100%) rename pyspark/{pyspark => }/examples/tc.py (100%) rename pyspark/{pyspark => }/examples/wordcount.py (100%) delete mode 100644 pyspark/pyspark/examples/__init__.py diff --git a/docs/_layouts/global.html b/docs/_layouts/global.html index 43a5fa3e1c..96eebd9f23 100755 --- a/docs/_layouts/global.html +++ b/docs/_layouts/global.html @@ -47,6 +47,7 @@

  • Quick Start
  • Scala
  • Java
    • +
  • Python
    • diff --git a/docs/api.md b/docs/api.md index 43548b223c..b9c93ac5e8 100644 --- a/docs/api.md +++ b/docs/api.md @@ -8,3 +8,4 @@ Here you can find links to the Scaladoc generated for the Spark sbt subprojects. - [Core](api/core/index.html) - [Examples](api/examples/index.html) - [Bagel](api/bagel/index.html) +- [PySpark](api/pyspark/index.html) diff --git a/docs/index.md b/docs/index.md index ed9953a590..33ab58a962 100644 --- a/docs/index.md +++ b/docs/index.md @@ -7,11 +7,11 @@ title: Spark Overview TODO(andyk): Rewrite to make the Java API a first class part of the story. {% endcomment %} -Spark is a MapReduce-like cluster computing framework designed for low-latency iterative jobs and interactive use from an -interpreter. It provides clean, language-integrated APIs in Scala and Java, with a rich array of parallel operators. Spark can -run on top of the [Apache Mesos](http://incubator.apache.org/mesos/) cluster manager, +Spark is a MapReduce-like cluster computing framework designed for low-latency iterative jobs and interactive use from an interpreter. +It provides clean, language-integrated APIs in Scala, Java, and Python, with a rich array of parallel operators. +Spark can run on top of the [Apache Mesos](http://incubator.apache.org/mesos/) cluster manager, [Hadoop YARN](http://hadoop.apache.org/docs/r2.0.1-alpha/hadoop-yarn/hadoop-yarn-site/YARN.html), -Amazon EC2, or without an independent resource manager ("standalone mode"). +Amazon EC2, or without an independent resource manager ("standalone mode"). # Downloading @@ -59,6 +59,7 @@ of `project/SparkBuild.scala`, then rebuilding Spark (`sbt/sbt clean compile`). * [Quick Start](quick-start.html): a quick introduction to the Spark API; start here! * [Spark Programming Guide](scala-programming-guide.html): an overview of Spark concepts, and details on the Scala API * [Java Programming Guide](java-programming-guide.html): using Spark from Java +* [Python Programming Guide](python-programming-guide.html): using Spark from Python **Deployment guides:** @@ -72,7 +73,7 @@ of `project/SparkBuild.scala`, then rebuilding Spark (`sbt/sbt clean compile`). * [Configuration](configuration.html): customize Spark via its configuration system * [Tuning Guide](tuning.html): best practices to optimize performance and memory use -* [API Docs (Scaladoc)](api/core/index.html) +* API Docs: [Java/Scala (Scaladoc)](api/core/index.html) and [Python (Epydoc)](api/pyspark/index.html) * [Bagel](bagel-programming-guide.html): an implementation of Google's Pregel on Spark * [Contributing to Spark](contributing-to-spark.html) diff --git a/docs/python-programming-guide.md b/docs/python-programming-guide.md new file mode 100644 index 0000000000..b7c747f905 --- /dev/null +++ b/docs/python-programming-guide.md @@ -0,0 +1,74 @@ +--- +layout: global +title: Python Programming Guide +--- + + +The Spark Python API (PySpark) exposes most of the Spark features available in the Scala version to Python. +To learn the basics of Spark, we recommend reading through the +[Scala programming guide](scala-programming-guide.html) first; it should be +easy to follow even if you don't know Scala. +This guide will show how to use the Spark features described there in Python. + +# Key Differences in the Python API + +There are a few key differences between the Python and Scala APIs: + +* Python is dynamically typed, so RDDs can hold objects of different types. +* PySpark does not currently support the following Spark features: + - Accumulators + - Special functions on RRDs of doubles, such as `mean` and `stdev` + - Approximate jobs / functions, such as `countApprox` and `sumApprox`. + - `lookup` + - `mapPartitionsWithSplit` + - `persist` at storage levels other than `MEMORY_ONLY` + - `sample` + - `sort` + + +# Installing and Configuring PySpark + +PySpark requires Python 2.6 or higher. +PySpark jobs are executed using a standard cPython interpreter in order to support Python modules that use C extensions. +We have not tested PySpark with Python 3 or with alternative Python interpreters, such as [PyPy](http://pypy.org/) or [Jython](http://www.jython.org/). +By default, PySpark's scripts will run programs using `python`; an alternate Python executable may be specified by setting the `PYSPARK_PYTHON` environment variable in `conf/spark-env.sh`. + +All of PySpark's library dependencies, including [Py4J](http://py4j.sourceforge.net/), are bundled with PySpark and automatically imported. + +Standalone PySpark jobs should be run using the `run-pyspark` script, which automatically configures the Java and Python environmnt using the settings in `conf/spark-env.sh`. +The script automatically adds the `pyspark` package to the `PYTHONPATH`. + + +# Interactive Use + +PySpark's `pyspark-shell` script provides a simple way to learn the API: + +{% highlight python %} +>>> words = sc.textFile("/usr/share/dict/words") +>>> words.filter(lambda w: w.startswith("spar")).take(5) +[u'spar', u'sparable', u'sparada', u'sparadrap', u'sparagrass'] +{% endhighlight %} + +# Standalone Use + +PySpark can also be used from standalone Python scripts by creating a SparkContext in the script and running the script using the `run-pyspark` script in the `pyspark` directory. +The Quick Start guide includes a [complete example](quick-start.html#a-standalone-job-in-python) of a standalone Python job. + +Code dependencies can be deployed by listing them in the `pyFiles` option in the SparkContext constructor: + +{% highlight python %} +from pyspark import SparkContext +sc = SparkContext("local", "Job Name", pyFiles=['MyFile.py', 'lib.zip', 'app.egg']) +{% endhighlight %} + +Files listed here will be added to the `PYTHONPATH` and shipped to remote worker machines. +Code dependencies can be added to an existing SparkContext using its `addPyFile()` method. + +# Where to Go from Here + +PySpark includes several sample programs using the Python API in `pyspark/examples`. +You can run them by passing the files to the `pyspark-run` script included in PySpark -- for example `./pyspark-run examples/wordcount.py`. +Each example program prints usage help when run without any arguments. + +We currently provide [API documentation](api/pyspark/index.html) for the Python API as Epydoc. +Many of the RDD method descriptions contain [doctests](http://docs.python.org/2/library/doctest.html) that provide additional usage examples. diff --git a/docs/quick-start.md b/docs/quick-start.md index defdb34836..c859c31b09 100644 --- a/docs/quick-start.md +++ b/docs/quick-start.md @@ -6,7 +6,8 @@ title: Quick Start * This will become a table of contents (this text will be scraped). {:toc} -This tutorial provides a quick introduction to using Spark. We will first introduce the API through Spark's interactive Scala shell (don't worry if you don't know Scala -- you will need much for this), then show how to write standalone jobs in Scala and Java. See the [programming guide](scala-programming-guide.html) for a fuller reference. +This tutorial provides a quick introduction to using Spark. We will first introduce the API through Spark's interactive Scala shell (don't worry if you don't know Scala -- you will need much for this), then show how to write standalone jobs in Scala, Java, and Python. +See the [programming guide](scala-programming-guide.html) for a more complete reference. To follow along with this guide, you only need to have successfully built Spark on one machine. Simply go into your Spark directory and run: @@ -230,3 +231,40 @@ Lines with a: 8422, Lines with b: 1836 {% endhighlight %} This example only runs the job locally; for a tutorial on running jobs across several machines, see the [Standalone Mode](spark-standalone.html) documentation, and consider using a distributed input source, such as HDFS. + +# A Standalone Job In Python +Now we will show how to write a standalone job using the Python API (PySpark). + +As an example, we'll create a simple Spark job, `SimpleJob.py`: + +{% highlight python %} +"""SimpleJob.py""" +from pyspark import SparkContext + +logFile = "/var/log/syslog" # Should be some file on your system +sc = SparkContext("local", "Simple job") +logData = sc.textFile(logFile).cache() + +numAs = logData.filter(lambda s: 'a' in s).count() +numBs = logData.filter(lambda s: 'b' in s).count() + +print "Lines with a: %i, lines with b: %i" % (numAs, numBs) +{% endhighlight %} + + +This job simply counts the number of lines containing 'a' and the number containing 'b' in a system log file. +Like in the Scala and Java examples, we use a SparkContext to create RDDs. +We can pass Python functions to Spark, which are automatically serialized along with any variables that they reference. +For jobs that use custom classes or third-party libraries, we can add those code dependencies to SparkContext to ensure that they will be available on remote machines; this is described in more detail in the [Python programming guide](python-programming-guide). +`SimpleJob` is simple enough that we do not need to specify any code dependencies. + +We can run this job using the `run-pyspark` script in `$SPARK_HOME/pyspark`: + +{% highlight python %} +$ cd $SPARK_HOME +$ ./pyspark/run-pyspark SimpleJob.py +... +Lines with a: 8422, Lines with b: 1836 +{% endhighlight python %} + +This example only runs the job locally; for a tutorial on running jobs across several machines, see the [Standalone Mode](spark-standalone.html) documentation, and consider using a distributed input source, such as HDFS. diff --git a/pyspark/README b/pyspark/README deleted file mode 100644 index d8d521c72c..0000000000 --- a/pyspark/README +++ /dev/null @@ -1,42 +0,0 @@ -# PySpark - -PySpark is a Python API for Spark. - -PySpark jobs are writen in Python and executed using a standard Python -interpreter; this supports modules that use Python C extensions. The -API is based on the Spark Scala API and uses regular Python functions -and lambdas to support user-defined functions. PySpark supports -interactive use through a standard Python interpreter; it can -automatically serialize closures and ship them to worker processes. - -PySpark is built on top of the Spark Java API. Data is uniformly -represented as serialized Python objects and stored in Spark Java -processes, which communicate with PySpark worker processes over pipes. - -## Features - -PySpark supports most of the Spark API, including broadcast variables. -RDDs are dynamically typed and can hold any Python object. - -PySpark does not support: - -- Special functions on RDDs of doubles -- Accumulators - -## Examples and Documentation - -The PySpark source contains docstrings and doctests that document its -API. The public classes are in `context.py` and `rdd.py`. - -The `pyspark/pyspark/examples` directory contains a few complete -examples. - -## Installing PySpark -# -To use PySpark, `SPARK_HOME` should be set to the location of the Spark -package. - -## Running PySpark - -The easiest way to run PySpark is to use the `run-pyspark` and -`pyspark-shell` scripts, which are included in the `pyspark` directory. diff --git a/pyspark/pyspark/examples/kmeans.py b/pyspark/examples/kmeans.py similarity index 100% rename from pyspark/pyspark/examples/kmeans.py rename to pyspark/examples/kmeans.py diff --git a/pyspark/pyspark/examples/pi.py b/pyspark/examples/pi.py similarity index 100% rename from pyspark/pyspark/examples/pi.py rename to pyspark/examples/pi.py diff --git a/pyspark/pyspark/examples/tc.py b/pyspark/examples/tc.py similarity index 100% rename from pyspark/pyspark/examples/tc.py rename to pyspark/examples/tc.py diff --git a/pyspark/pyspark/examples/wordcount.py b/pyspark/examples/wordcount.py similarity index 100% rename from pyspark/pyspark/examples/wordcount.py rename to pyspark/examples/wordcount.py diff --git a/pyspark/pyspark/__init__.py b/pyspark/pyspark/__init__.py index 549c2d2711..8f8402b62b 100644 --- a/pyspark/pyspark/__init__.py +++ b/pyspark/pyspark/__init__.py @@ -1,3 +1,9 @@ import sys import os sys.path.insert(0, os.path.join(os.environ["SPARK_HOME"], "pyspark/lib/py4j0.7.egg")) + + +from pyspark.context import SparkContext + + +__all__ = ["SparkContext"] diff --git a/pyspark/pyspark/examples/__init__.py b/pyspark/pyspark/examples/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 From 6ee1ff2663cf1f776dd33e448548a8ddcf974dc6 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 29 Dec 2012 22:22:56 +0000 Subject: [PATCH 32/85] Fix bug in pyspark.serializers.batch; add .gitignore. --- pyspark/.gitignore | 2 ++ pyspark/pyspark/rdd.py | 4 +++- pyspark/pyspark/serializers.py | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) create mode 100644 pyspark/.gitignore diff --git a/pyspark/.gitignore b/pyspark/.gitignore new file mode 100644 index 0000000000..5c56e638f9 --- /dev/null +++ b/pyspark/.gitignore @@ -0,0 +1,2 @@ +*.pyc +docs/ diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 111476d274..20f84b2dd0 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -695,7 +695,9 @@ def _test(): import doctest from pyspark.context import SparkContext globs = globals().copy() - globs['sc'] = SparkContext('local[4]', 'PythonTest') + # The small batch size here ensures that we see multiple batches, + # even in these small test examples: + globs['sc'] = SparkContext('local[4]', 'PythonTest', batchSize=2) doctest.testmod(globs=globs) globs['sc'].stop() diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index 4ed925697c..8b08f7ef0f 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -24,7 +24,7 @@ def batched(iterator, batchSize): if count == batchSize: yield Batch(items) items = [] - count = [] + count = 0 if items: yield Batch(items) From 26186e2d259f3aa2db9c8594097fd342107ce147 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 29 Dec 2012 15:34:57 -0800 Subject: [PATCH 33/85] Use batching in pyspark parallelize(); fix cartesian() --- pyspark/pyspark/context.py | 4 +++- pyspark/pyspark/rdd.py | 31 +++++++++++++++---------------- pyspark/pyspark/serializers.py | 23 +++++++++++++---------- 3 files changed, 31 insertions(+), 27 deletions(-) diff --git a/pyspark/pyspark/context.py b/pyspark/pyspark/context.py index b90596ecc2..6172d69dcf 100644 --- a/pyspark/pyspark/context.py +++ b/pyspark/pyspark/context.py @@ -4,7 +4,7 @@ from tempfile import NamedTemporaryFile from pyspark.broadcast import Broadcast from pyspark.java_gateway import launch_gateway -from pyspark.serializers import dump_pickle, write_with_length +from pyspark.serializers import dump_pickle, write_with_length, batched from pyspark.rdd import RDD from py4j.java_collections import ListConverter @@ -91,6 +91,8 @@ class SparkContext(object): # objects are written to a file and loaded through textFile(). tempFile = NamedTemporaryFile(delete=False) atexit.register(lambda: os.unlink(tempFile.name)) + if self.batchSize != 1: + c = batched(c, self.batchSize) for x in c: write_with_length(dump_pickle(x), tempFile) tempFile.close() diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 20f84b2dd0..203f7377d2 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -2,7 +2,7 @@ import atexit from base64 import standard_b64encode as b64enc import copy from collections import defaultdict -from itertools import chain, ifilter, imap +from itertools import chain, ifilter, imap, product import operator import os import shlex @@ -123,12 +123,6 @@ class RDD(object): >>> rdd = sc.parallelize([1, 1, 2, 3]) >>> rdd.union(rdd).collect() [1, 1, 2, 3, 1, 1, 2, 3] - - Union of batched and unbatched RDDs (internal test): - - >>> batchedRDD = sc.parallelize([Batch([1, 2, 3, 4, 5])]) - >>> rdd.union(batchedRDD).collect() - [1, 1, 2, 3, 1, 2, 3, 4, 5] """ return RDD(self._jrdd.union(other._jrdd), self.ctx) @@ -168,7 +162,18 @@ class RDD(object): >>> sorted(rdd.cartesian(rdd).collect()) [(1, 1), (1, 2), (2, 1), (2, 2)] """ - return RDD(self._jrdd.cartesian(other._jrdd), self.ctx) + # Due to batching, we can't use the Java cartesian method. + java_cartesian = RDD(self._jrdd.cartesian(other._jrdd), self.ctx) + def unpack_batches(pair): + (x, y) = pair + if type(x) == Batch or type(y) == Batch: + xs = x.items if type(x) == Batch else [x] + ys = y.items if type(y) == Batch else [y] + for pair in product(xs, ys): + yield pair + else: + yield pair + return java_cartesian.flatMap(unpack_batches) def groupBy(self, f, numSplits=None): """ @@ -293,8 +298,6 @@ class RDD(object): >>> sc.parallelize([2, 3, 4]).count() 3 - >>> sc.parallelize([Batch([2, 3, 4])]).count() - 3 """ return self.mapPartitions(lambda i: [sum(1 for _ in i)]).sum() @@ -667,12 +670,8 @@ class PipelinedRDD(RDD): if not self._bypass_serializer and self.ctx.batchSize != 1: oldfunc = self.func batchSize = self.ctx.batchSize - if batchSize == -1: # unlimited batch size - def batched_func(iterator): - yield Batch(list(oldfunc(iterator))) - else: - def batched_func(iterator): - return batched(oldfunc(iterator), batchSize) + def batched_func(iterator): + return batched(oldfunc(iterator), batchSize) func = batched_func cmds = [func, self._bypass_serializer] pipe_command = ' '.join(b64enc(cloudpickle.dumps(f)) for f in cmds) diff --git a/pyspark/pyspark/serializers.py b/pyspark/pyspark/serializers.py index 8b08f7ef0f..9a5151ea00 100644 --- a/pyspark/pyspark/serializers.py +++ b/pyspark/pyspark/serializers.py @@ -16,17 +16,20 @@ class Batch(object): def batched(iterator, batchSize): - items = [] - count = 0 - for item in iterator: - items.append(item) - count += 1 - if count == batchSize: + if batchSize == -1: # unlimited batch size + yield Batch(list(iterator)) + else: + items = [] + count = 0 + for item in iterator: + items.append(item) + count += 1 + if count == batchSize: + yield Batch(items) + items = [] + count = 0 + if items: yield Batch(items) - items = [] - count = 0 - if items: - yield Batch(items) def dump_pickle(obj): From 59195c68ec37acf20d527189ed757397b273a207 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 29 Dec 2012 16:01:03 -0800 Subject: [PATCH 34/85] Update PySpark for compatibility with TaskContext. --- .../src/main/scala/spark/api/python/PythonRDD.scala | 13 +++++-------- pyspark/pyspark/rdd.py | 3 ++- 2 files changed, 7 insertions(+), 9 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index f76616a4c4..dc48378fdc 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -8,10 +8,7 @@ import scala.io.Source import spark.api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} import spark.broadcast.Broadcast -import spark.SparkEnv -import spark.Split -import spark.RDD -import spark.OneToOneDependency +import spark._ import spark.rdd.PipedRDD @@ -34,7 +31,7 @@ private[spark] class PythonRDD[T: ClassManifest]( override val partitioner = if (preservePartitoning) parent.partitioner else None - override def compute(split: Split): Iterator[Array[Byte]] = { + override def compute(split: Split, context: TaskContext): Iterator[Array[Byte]] = { val SPARK_HOME = new ProcessBuilder().environment().get("SPARK_HOME") val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) @@ -74,7 +71,7 @@ private[spark] class PythonRDD[T: ClassManifest]( out.println(elem) } out.flush() - for (elem <- parent.iterator(split)) { + for (elem <- parent.iterator(split, context)) { PythonRDD.writeAsPickle(elem, dOut) } dOut.flush() @@ -123,8 +120,8 @@ private class PairwiseRDD(prev: RDD[Array[Byte]]) extends RDD[(Array[Byte], Array[Byte])](prev.context) { override def splits = prev.splits override val dependencies = List(new OneToOneDependency(prev)) - override def compute(split: Split) = - prev.iterator(split).grouped(2).map { + override def compute(split: Split, context: TaskContext) = + prev.iterator(split, context).grouped(2).map { case Seq(a, b) => (a, b) case x => throw new Exception("PairwiseRDD: unexpected value: " + x) } diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 203f7377d2..21dda31c4e 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -335,9 +335,10 @@ class RDD(object): """ items = [] splits = self._jrdd.splits() + taskContext = self.ctx.jvm.spark.TaskContext(0, 0, 0) while len(items) < num and splits: split = splits.pop(0) - iterator = self._jrdd.iterator(split) + iterator = self._jrdd.iterator(split, taskContext) items.extend(self._collect_iterator_through_file(iterator)) return items[:num] From 39dd953fd88e9aa7335603ab452d9c1bed4ba67a Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 29 Dec 2012 17:06:50 -0800 Subject: [PATCH 35/85] Add test for pyspark.RDD.saveAsTextFile(). --- pyspark/pyspark/rdd.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pyspark/pyspark/rdd.py b/pyspark/pyspark/rdd.py index 21dda31c4e..cbffb6cc1f 100644 --- a/pyspark/pyspark/rdd.py +++ b/pyspark/pyspark/rdd.py @@ -351,10 +351,17 @@ class RDD(object): """ return self.take(1)[0] - # TODO: add test and fix for use with Batch def saveAsTextFile(self, path): """ Save this RDD as a text file, using string representations of elements. + + >>> tempFile = NamedTemporaryFile(delete=True) + >>> tempFile.close() + >>> sc.parallelize(range(10)).saveAsTextFile(tempFile.name) + >>> from fileinput import input + >>> from glob import glob + >>> ''.join(input(glob(tempFile.name + "/part-0000*"))) + '0\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n' """ def func(iterator): return (str(x).encode("utf-8") for x in iterator) From 099898b43955d99351ec94d4a373de854bf7edf7 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Sat, 29 Dec 2012 17:52:47 -0800 Subject: [PATCH 36/85] Port LR example to PySpark using numpy. This version of the example crashes after the first iteration with "OverflowError: math range error" because Python's math.exp() behaves differently than Scala's; see SPARK-646. --- pyspark/examples/lr.py | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100755 pyspark/examples/lr.py diff --git a/pyspark/examples/lr.py b/pyspark/examples/lr.py new file mode 100755 index 0000000000..5fca0266b8 --- /dev/null +++ b/pyspark/examples/lr.py @@ -0,0 +1,57 @@ +""" +This example requires numpy (http://www.numpy.org/) +""" +from collections import namedtuple +from math import exp +from os.path import realpath +import sys + +import numpy as np +from pyspark.context import SparkContext + + +N = 100000 # Number of data points +D = 10 # Number of dimensions +R = 0.7 # Scaling factor +ITERATIONS = 5 +np.random.seed(42) + + +DataPoint = namedtuple("DataPoint", ['x', 'y']) +from lr import DataPoint # So that DataPoint is properly serialized + + +def generateData(): + def generatePoint(i): + y = -1 if i % 2 == 0 else 1 + x = np.random.normal(size=D) + (y * R) + return DataPoint(x, y) + return [generatePoint(i) for i in range(N)] + + +if __name__ == "__main__": + if len(sys.argv) == 1: + print >> sys.stderr, \ + "Usage: PythonLR []" + exit(-1) + sc = SparkContext(sys.argv[1], "PythonLR", pyFiles=[realpath(__file__)]) + slices = int(sys.argv[2]) if len(sys.argv) > 2 else 2 + points = sc.parallelize(generateData(), slices).cache() + + # Initialize w to a random value + w = 2 * np.random.ranf(size=D) - 1 + print "Initial w: " + str(w) + + def add(x, y): + x += y + return x + + for i in range(1, ITERATIONS + 1): + print "On iteration %i" % i + + gradient = points.map(lambda p: + (1.0 / (1.0 + exp(-p.y * np.dot(w, p.x)))) * p.y * p.x + ).reduce(add) + w -= gradient + + print "Final w: " + str(w) From 6f6a6b79c4c3f3555f8ff427c91e714d02afe8fa Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Mon, 31 Dec 2012 14:56:23 -0800 Subject: [PATCH 37/85] Launch with `scala` by default in run-pyspark --- pyspark/run-pyspark | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pyspark/run-pyspark b/pyspark/run-pyspark index f8039b8038..4d10fbea8b 100755 --- a/pyspark/run-pyspark +++ b/pyspark/run-pyspark @@ -20,4 +20,9 @@ export PYSPARK_PYTHON # Add the PySpark classes to the Python path: export PYTHONPATH=$SPARK_HOME/pyspark/:$PYTHONPATH +# Launch with `scala` by default: +if [[ "$SPARK_LAUNCH_WITH_SCALA" != "0" ]] ; then + export SPARK_LAUNCH_WITH_SCALA=1 +fi + exec "$PYSPARK_PYTHON" "$@" From 170e451fbdd308ae77065bd9c0f2bd278abf0cb7 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Tue, 1 Jan 2013 13:52:14 -0800 Subject: [PATCH 38/85] Minor documentation and style fixes for PySpark. --- .../spark/api/python/PythonPartitioner.scala | 4 +- .../scala/spark/api/python/PythonRDD.scala | 43 +++++++++++++------ docs/index.md | 8 +++- docs/python-programming-guide.md | 3 +- pyspark/examples/kmeans.py | 13 +++--- .../{lr.py => logistic_regression.py} | 4 +- pyspark/examples/pi.py | 5 ++- .../examples/{tc.py => transitive_closure.py} | 5 ++- pyspark/examples/wordcount.py | 4 +- pyspark/pyspark/__init__.py | 13 +++++- 10 files changed, 70 insertions(+), 32 deletions(-) rename pyspark/examples/{lr.py => logistic_regression.py} (93%) rename pyspark/examples/{tc.py => transitive_closure.py} (94%) diff --git a/core/src/main/scala/spark/api/python/PythonPartitioner.scala b/core/src/main/scala/spark/api/python/PythonPartitioner.scala index 2c829508e5..648d9402b0 100644 --- a/core/src/main/scala/spark/api/python/PythonPartitioner.scala +++ b/core/src/main/scala/spark/api/python/PythonPartitioner.scala @@ -17,9 +17,9 @@ private[spark] class PythonPartitioner(override val numPartitions: Int) extends val hashCode = { if (key.isInstanceOf[Array[Byte]]) { Arrays.hashCode(key.asInstanceOf[Array[Byte]]) - } - else + } else { key.hashCode() + } } val mod = hashCode % numPartitions if (mod < 0) { diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index dc48378fdc..19a039e330 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -13,8 +13,12 @@ import spark.rdd.PipedRDD private[spark] class PythonRDD[T: ClassManifest]( - parent: RDD[T], command: Seq[String], envVars: java.util.Map[String, String], - preservePartitoning: Boolean, pythonExec: String, broadcastVars: java.util.List[Broadcast[Array[Byte]]]) + parent: RDD[T], + command: Seq[String], + envVars: java.util.Map[String, String], + preservePartitoning: Boolean, + pythonExec: String, + broadcastVars: java.util.List[Broadcast[Array[Byte]]]) extends RDD[Array[Byte]](parent.context) { // Similar to Runtime.exec(), if we are given a single string, split it into words @@ -38,8 +42,8 @@ private[spark] class PythonRDD[T: ClassManifest]( // Add the environmental variables to the process. val currentEnvVars = pb.environment() - envVars.foreach { - case (variable, value) => currentEnvVars.put(variable, value) + for ((variable, value) <- envVars) { + currentEnvVars.put(variable, value) } val proc = pb.start() @@ -116,6 +120,10 @@ private[spark] class PythonRDD[T: ClassManifest]( val asJavaRDD : JavaRDD[Array[Byte]] = JavaRDD.fromRDD(this) } +/** + * Form an RDD[(Array[Byte], Array[Byte])] from key-value pairs returned from Python. + * This is used by PySpark's shuffle operations. + */ private class PairwiseRDD(prev: RDD[Array[Byte]]) extends RDD[(Array[Byte], Array[Byte])](prev.context) { override def splits = prev.splits @@ -139,6 +147,16 @@ private[spark] object PythonRDD { * Write strings, pickled Python objects, or pairs of pickled objects to a data output stream. * The data format is a 32-bit integer representing the pickled object's length (in bytes), * followed by the pickled data. + * + * Pickle module: + * + * http://docs.python.org/2/library/pickle.html + * + * The pickle protocol is documented in the source of the `pickle` and `pickletools` modules: + * + * http://hg.python.org/cpython/file/2.6/Lib/pickle.py + * http://hg.python.org/cpython/file/2.6/Lib/pickletools.py + * * @param elem the object to write * @param dOut a data output stream */ @@ -201,15 +219,14 @@ private[spark] object PythonRDD { } private object Pickle { - def b(x: Int): Byte = x.asInstanceOf[Byte] - val PROTO: Byte = b(0x80) - val TWO: Byte = b(0x02) - val BINUNICODE : Byte = 'X' - val STOP : Byte = '.' - val TUPLE2 : Byte = b(0x86) - val EMPTY_LIST : Byte = ']' - val MARK : Byte = '(' - val APPENDS : Byte = 'e' + val PROTO: Byte = 0x80.toByte + val TWO: Byte = 0x02.toByte + val BINUNICODE: Byte = 'X' + val STOP: Byte = '.' + val TUPLE2: Byte = 0x86.toByte + val EMPTY_LIST: Byte = ']' + val MARK: Byte = '(' + val APPENDS: Byte = 'e' } private class ExtractValue extends spark.api.java.function.Function[(Array[Byte], diff --git a/docs/index.md b/docs/index.md index 33ab58a962..848b585333 100644 --- a/docs/index.md +++ b/docs/index.md @@ -8,7 +8,7 @@ TODO(andyk): Rewrite to make the Java API a first class part of the story. {% endcomment %} Spark is a MapReduce-like cluster computing framework designed for low-latency iterative jobs and interactive use from an interpreter. -It provides clean, language-integrated APIs in Scala, Java, and Python, with a rich array of parallel operators. +It provides clean, language-integrated APIs in [Scala](scala-programming-guide.html), [Java](java-programming-guide.html), and [Python](python-programming-guide.html), with a rich array of parallel operators. Spark can run on top of the [Apache Mesos](http://incubator.apache.org/mesos/) cluster manager, [Hadoop YARN](http://hadoop.apache.org/docs/r2.0.1-alpha/hadoop-yarn/hadoop-yarn-site/YARN.html), Amazon EC2, or without an independent resource manager ("standalone mode"). @@ -61,6 +61,11 @@ of `project/SparkBuild.scala`, then rebuilding Spark (`sbt/sbt clean compile`). * [Java Programming Guide](java-programming-guide.html): using Spark from Java * [Python Programming Guide](python-programming-guide.html): using Spark from Python +**API Docs:** + +* [Java/Scala (Scaladoc)](api/core/index.html) +* [Python (Epydoc)](api/pyspark/index.html) + **Deployment guides:** * [Running Spark on Amazon EC2](ec2-scripts.html): scripts that let you launch a cluster on EC2 in about 5 minutes @@ -73,7 +78,6 @@ of `project/SparkBuild.scala`, then rebuilding Spark (`sbt/sbt clean compile`). * [Configuration](configuration.html): customize Spark via its configuration system * [Tuning Guide](tuning.html): best practices to optimize performance and memory use -* API Docs: [Java/Scala (Scaladoc)](api/core/index.html) and [Python (Epydoc)](api/pyspark/index.html) * [Bagel](bagel-programming-guide.html): an implementation of Google's Pregel on Spark * [Contributing to Spark](contributing-to-spark.html) diff --git a/docs/python-programming-guide.md b/docs/python-programming-guide.md index b7c747f905..d88d4eb42d 100644 --- a/docs/python-programming-guide.md +++ b/docs/python-programming-guide.md @@ -17,8 +17,7 @@ There are a few key differences between the Python and Scala APIs: * Python is dynamically typed, so RDDs can hold objects of different types. * PySpark does not currently support the following Spark features: - Accumulators - - Special functions on RRDs of doubles, such as `mean` and `stdev` - - Approximate jobs / functions, such as `countApprox` and `sumApprox`. + - Special functions on RDDs of doubles, such as `mean` and `stdev` - `lookup` - `mapPartitionsWithSplit` - `persist` at storage levels other than `MEMORY_ONLY` diff --git a/pyspark/examples/kmeans.py b/pyspark/examples/kmeans.py index 9cc366f03c..ad2be21178 100644 --- a/pyspark/examples/kmeans.py +++ b/pyspark/examples/kmeans.py @@ -1,18 +1,21 @@ +""" +This example requires numpy (http://www.numpy.org/) +""" import sys -from pyspark.context import SparkContext -from numpy import array, sum as np_sum +import numpy as np +from pyspark import SparkContext def parseVector(line): - return array([float(x) for x in line.split(' ')]) + return np.array([float(x) for x in line.split(' ')]) def closestPoint(p, centers): bestIndex = 0 closest = float("+inf") for i in range(len(centers)): - tempDist = np_sum((p - centers[i]) ** 2) + tempDist = np.sum((p - centers[i]) ** 2) if tempDist < closest: closest = tempDist bestIndex = i @@ -41,7 +44,7 @@ if __name__ == "__main__": newPoints = pointStats.map( lambda (x, (y, z)): (x, y / z)).collect() - tempDist = sum(np_sum((kPoints[x] - y) ** 2) for (x, y) in newPoints) + tempDist = sum(np.sum((kPoints[x] - y) ** 2) for (x, y) in newPoints) for (x, y) in newPoints: kPoints[x] = y diff --git a/pyspark/examples/lr.py b/pyspark/examples/logistic_regression.py similarity index 93% rename from pyspark/examples/lr.py rename to pyspark/examples/logistic_regression.py index 5fca0266b8..f13698a86f 100755 --- a/pyspark/examples/lr.py +++ b/pyspark/examples/logistic_regression.py @@ -7,7 +7,7 @@ from os.path import realpath import sys import numpy as np -from pyspark.context import SparkContext +from pyspark import SparkContext N = 100000 # Number of data points @@ -32,7 +32,7 @@ def generateData(): if __name__ == "__main__": if len(sys.argv) == 1: print >> sys.stderr, \ - "Usage: PythonLR []" + "Usage: PythonLR []" exit(-1) sc = SparkContext(sys.argv[1], "PythonLR", pyFiles=[realpath(__file__)]) slices = int(sys.argv[2]) if len(sys.argv) > 2 else 2 diff --git a/pyspark/examples/pi.py b/pyspark/examples/pi.py index 348bbc5dce..127cba029b 100644 --- a/pyspark/examples/pi.py +++ b/pyspark/examples/pi.py @@ -1,13 +1,14 @@ import sys from random import random from operator import add -from pyspark.context import SparkContext + +from pyspark import SparkContext if __name__ == "__main__": if len(sys.argv) == 1: print >> sys.stderr, \ - "Usage: PythonPi []" + "Usage: PythonPi []" exit(-1) sc = SparkContext(sys.argv[1], "PythonPi") slices = int(sys.argv[2]) if len(sys.argv) > 2 else 2 diff --git a/pyspark/examples/tc.py b/pyspark/examples/transitive_closure.py similarity index 94% rename from pyspark/examples/tc.py rename to pyspark/examples/transitive_closure.py index 9630e72b47..73f7f8fbaf 100644 --- a/pyspark/examples/tc.py +++ b/pyspark/examples/transitive_closure.py @@ -1,6 +1,7 @@ import sys from random import Random -from pyspark.context import SparkContext + +from pyspark import SparkContext numEdges = 200 numVertices = 100 @@ -20,7 +21,7 @@ def generateGraph(): if __name__ == "__main__": if len(sys.argv) == 1: print >> sys.stderr, \ - "Usage: PythonTC []" + "Usage: PythonTC []" exit(-1) sc = SparkContext(sys.argv[1], "PythonTC") slices = sys.argv[2] if len(sys.argv) > 2 else 2 diff --git a/pyspark/examples/wordcount.py b/pyspark/examples/wordcount.py index 8365c070e8..857160624b 100644 --- a/pyspark/examples/wordcount.py +++ b/pyspark/examples/wordcount.py @@ -1,6 +1,8 @@ import sys from operator import add -from pyspark.context import SparkContext + +from pyspark import SparkContext + if __name__ == "__main__": if len(sys.argv) < 3: diff --git a/pyspark/pyspark/__init__.py b/pyspark/pyspark/__init__.py index 8f8402b62b..1ab360a666 100644 --- a/pyspark/pyspark/__init__.py +++ b/pyspark/pyspark/__init__.py @@ -1,9 +1,20 @@ +""" +PySpark is a Python API for Spark. + +Public classes: + + - L{SparkContext} + Main entry point for Spark functionality. + - L{RDD} + A Resilient Distributed Dataset (RDD), the basic abstraction in Spark. +""" import sys import os sys.path.insert(0, os.path.join(os.environ["SPARK_HOME"], "pyspark/lib/py4j0.7.egg")) from pyspark.context import SparkContext +from pyspark.rdd import RDD -__all__ = ["SparkContext"] +__all__ = ["SparkContext", "RDD"] From b58340dbd9a741331fc4c3829b08c093560056c2 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Tue, 1 Jan 2013 14:48:45 -0800 Subject: [PATCH 39/85] Rename top-level 'pyspark' directory to 'python' --- .../src/main/scala/spark/api/python/PythonRDD.scala | 2 +- docs/_plugins/copy_api_dirs.rb | 8 ++++---- pyspark-shell | 3 +++ pyspark/pyspark-shell | 3 --- {pyspark => python}/.gitignore | 0 {pyspark => python}/epydoc.conf | 0 {pyspark => python}/examples/kmeans.py | 0 {pyspark => python}/examples/logistic_regression.py | 0 {pyspark => python}/examples/pi.py | 0 {pyspark => python}/examples/transitive_closure.py | 0 {pyspark => python}/examples/wordcount.py | 0 {pyspark => python}/lib/PY4J_LICENSE.txt | 0 {pyspark => python}/lib/PY4J_VERSION.txt | 0 {pyspark => python}/lib/py4j0.7.egg | Bin {pyspark => python}/lib/py4j0.7.jar | Bin {pyspark => python}/pyspark/__init__.py | 2 +- {pyspark => python}/pyspark/broadcast.py | 0 {pyspark => python}/pyspark/cloudpickle.py | 0 {pyspark => python}/pyspark/context.py | 0 {pyspark => python}/pyspark/java_gateway.py | 0 {pyspark => python}/pyspark/join.py | 0 {pyspark => python}/pyspark/rdd.py | 0 {pyspark => python}/pyspark/serializers.py | 0 {pyspark => python}/pyspark/shell.py | 0 {pyspark => python}/pyspark/worker.py | 0 run | 2 +- pyspark/run-pyspark => run-pyspark | 4 ++-- run2.cmd | 2 +- 28 files changed, 13 insertions(+), 13 deletions(-) create mode 100755 pyspark-shell delete mode 100755 pyspark/pyspark-shell rename {pyspark => python}/.gitignore (100%) rename {pyspark => python}/epydoc.conf (100%) rename {pyspark => python}/examples/kmeans.py (100%) rename {pyspark => python}/examples/logistic_regression.py (100%) rename {pyspark => python}/examples/pi.py (100%) rename {pyspark => python}/examples/transitive_closure.py (100%) rename {pyspark => python}/examples/wordcount.py (100%) rename {pyspark => python}/lib/PY4J_LICENSE.txt (100%) rename {pyspark => python}/lib/PY4J_VERSION.txt (100%) rename {pyspark => python}/lib/py4j0.7.egg (100%) rename {pyspark => python}/lib/py4j0.7.jar (100%) rename {pyspark => python}/pyspark/__init__.py (82%) rename {pyspark => python}/pyspark/broadcast.py (100%) rename {pyspark => python}/pyspark/cloudpickle.py (100%) rename {pyspark => python}/pyspark/context.py (100%) rename {pyspark => python}/pyspark/java_gateway.py (100%) rename {pyspark => python}/pyspark/join.py (100%) rename {pyspark => python}/pyspark/rdd.py (100%) rename {pyspark => python}/pyspark/serializers.py (100%) rename {pyspark => python}/pyspark/shell.py (100%) rename {pyspark => python}/pyspark/worker.py (100%) rename pyspark/run-pyspark => run-pyspark (86%) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 19a039e330..cf60d14f03 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -38,7 +38,7 @@ private[spark] class PythonRDD[T: ClassManifest]( override def compute(split: Split, context: TaskContext): Iterator[Array[Byte]] = { val SPARK_HOME = new ProcessBuilder().environment().get("SPARK_HOME") - val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/pyspark/pyspark/worker.py")) + val pb = new ProcessBuilder(Seq(pythonExec, SPARK_HOME + "/python/pyspark/worker.py")) // Add the environmental variables to the process. val currentEnvVars = pb.environment() diff --git a/docs/_plugins/copy_api_dirs.rb b/docs/_plugins/copy_api_dirs.rb index 577f3ebe70..c9ce589c1b 100644 --- a/docs/_plugins/copy_api_dirs.rb +++ b/docs/_plugins/copy_api_dirs.rb @@ -30,8 +30,8 @@ if ENV['SKIP_SCALADOC'] != '1' end if ENV['SKIP_EPYDOC'] != '1' - puts "Moving to pyspark directory and building epydoc." - cd("../pyspark") + puts "Moving to python directory and building epydoc." + cd("../python") puts `epydoc --config epydoc.conf` puts "Moving back into docs dir." @@ -40,8 +40,8 @@ if ENV['SKIP_EPYDOC'] != '1' puts "echo making directory pyspark" mkdir_p "pyspark" - puts "cp -r ../pyspark/docs/. api/pyspark" - cp_r("../pyspark/docs/.", "api/pyspark") + puts "cp -r ../python/docs/. api/pyspark" + cp_r("../python/docs/.", "api/pyspark") cd("..") end diff --git a/pyspark-shell b/pyspark-shell new file mode 100755 index 0000000000..27aaac3a26 --- /dev/null +++ b/pyspark-shell @@ -0,0 +1,3 @@ +#!/usr/bin/env bash +FWDIR="`dirname $0`" +exec $FWDIR/run-pyspark $FWDIR/python/pyspark/shell.py "$@" diff --git a/pyspark/pyspark-shell b/pyspark/pyspark-shell deleted file mode 100755 index e3736826e8..0000000000 --- a/pyspark/pyspark-shell +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env bash -FWDIR="`dirname $0`" -exec $FWDIR/run-pyspark $FWDIR/pyspark/shell.py "$@" diff --git a/pyspark/.gitignore b/python/.gitignore similarity index 100% rename from pyspark/.gitignore rename to python/.gitignore diff --git a/pyspark/epydoc.conf b/python/epydoc.conf similarity index 100% rename from pyspark/epydoc.conf rename to python/epydoc.conf diff --git a/pyspark/examples/kmeans.py b/python/examples/kmeans.py similarity index 100% rename from pyspark/examples/kmeans.py rename to python/examples/kmeans.py diff --git a/pyspark/examples/logistic_regression.py b/python/examples/logistic_regression.py similarity index 100% rename from pyspark/examples/logistic_regression.py rename to python/examples/logistic_regression.py diff --git a/pyspark/examples/pi.py b/python/examples/pi.py similarity index 100% rename from pyspark/examples/pi.py rename to python/examples/pi.py diff --git a/pyspark/examples/transitive_closure.py b/python/examples/transitive_closure.py similarity index 100% rename from pyspark/examples/transitive_closure.py rename to python/examples/transitive_closure.py diff --git a/pyspark/examples/wordcount.py b/python/examples/wordcount.py similarity index 100% rename from pyspark/examples/wordcount.py rename to python/examples/wordcount.py diff --git a/pyspark/lib/PY4J_LICENSE.txt b/python/lib/PY4J_LICENSE.txt similarity index 100% rename from pyspark/lib/PY4J_LICENSE.txt rename to python/lib/PY4J_LICENSE.txt diff --git a/pyspark/lib/PY4J_VERSION.txt b/python/lib/PY4J_VERSION.txt similarity index 100% rename from pyspark/lib/PY4J_VERSION.txt rename to python/lib/PY4J_VERSION.txt diff --git a/pyspark/lib/py4j0.7.egg b/python/lib/py4j0.7.egg similarity index 100% rename from pyspark/lib/py4j0.7.egg rename to python/lib/py4j0.7.egg diff --git a/pyspark/lib/py4j0.7.jar b/python/lib/py4j0.7.jar similarity index 100% rename from pyspark/lib/py4j0.7.jar rename to python/lib/py4j0.7.jar diff --git a/pyspark/pyspark/__init__.py b/python/pyspark/__init__.py similarity index 82% rename from pyspark/pyspark/__init__.py rename to python/pyspark/__init__.py index 1ab360a666..c595ae0842 100644 --- a/pyspark/pyspark/__init__.py +++ b/python/pyspark/__init__.py @@ -10,7 +10,7 @@ Public classes: """ import sys import os -sys.path.insert(0, os.path.join(os.environ["SPARK_HOME"], "pyspark/lib/py4j0.7.egg")) +sys.path.insert(0, os.path.join(os.environ["SPARK_HOME"], "python/lib/py4j0.7.egg")) from pyspark.context import SparkContext diff --git a/pyspark/pyspark/broadcast.py b/python/pyspark/broadcast.py similarity index 100% rename from pyspark/pyspark/broadcast.py rename to python/pyspark/broadcast.py diff --git a/pyspark/pyspark/cloudpickle.py b/python/pyspark/cloudpickle.py similarity index 100% rename from pyspark/pyspark/cloudpickle.py rename to python/pyspark/cloudpickle.py diff --git a/pyspark/pyspark/context.py b/python/pyspark/context.py similarity index 100% rename from pyspark/pyspark/context.py rename to python/pyspark/context.py diff --git a/pyspark/pyspark/java_gateway.py b/python/pyspark/java_gateway.py similarity index 100% rename from pyspark/pyspark/java_gateway.py rename to python/pyspark/java_gateway.py diff --git a/pyspark/pyspark/join.py b/python/pyspark/join.py similarity index 100% rename from pyspark/pyspark/join.py rename to python/pyspark/join.py diff --git a/pyspark/pyspark/rdd.py b/python/pyspark/rdd.py similarity index 100% rename from pyspark/pyspark/rdd.py rename to python/pyspark/rdd.py diff --git a/pyspark/pyspark/serializers.py b/python/pyspark/serializers.py similarity index 100% rename from pyspark/pyspark/serializers.py rename to python/pyspark/serializers.py diff --git a/pyspark/pyspark/shell.py b/python/pyspark/shell.py similarity index 100% rename from pyspark/pyspark/shell.py rename to python/pyspark/shell.py diff --git a/pyspark/pyspark/worker.py b/python/pyspark/worker.py similarity index 100% rename from pyspark/pyspark/worker.py rename to python/pyspark/worker.py diff --git a/run b/run index ed788c4db3..08e2b2434b 100755 --- a/run +++ b/run @@ -63,7 +63,7 @@ CORE_DIR="$FWDIR/core" REPL_DIR="$FWDIR/repl" EXAMPLES_DIR="$FWDIR/examples" BAGEL_DIR="$FWDIR/bagel" -PYSPARK_DIR="$FWDIR/pyspark" +PYSPARK_DIR="$FWDIR/python" # Build up classpath CLASSPATH="$SPARK_CLASSPATH" diff --git a/pyspark/run-pyspark b/run-pyspark similarity index 86% rename from pyspark/run-pyspark rename to run-pyspark index 4d10fbea8b..deb0d708b3 100755 --- a/pyspark/run-pyspark +++ b/run-pyspark @@ -1,7 +1,7 @@ #!/usr/bin/env bash # Figure out where the Scala framework is installed -FWDIR="$(cd `dirname $0`; cd ../; pwd)" +FWDIR="$(cd `dirname $0`; pwd)" # Export this as SPARK_HOME export SPARK_HOME="$FWDIR" @@ -18,7 +18,7 @@ fi export PYSPARK_PYTHON # Add the PySpark classes to the Python path: -export PYTHONPATH=$SPARK_HOME/pyspark/:$PYTHONPATH +export PYTHONPATH=$SPARK_HOME/python/:$PYTHONPATH # Launch with `scala` by default: if [[ "$SPARK_LAUNCH_WITH_SCALA" != "0" ]] ; then diff --git a/run2.cmd b/run2.cmd index 9c50804e69..83464b1166 100644 --- a/run2.cmd +++ b/run2.cmd @@ -34,7 +34,7 @@ set CORE_DIR=%FWDIR%core set REPL_DIR=%FWDIR%repl set EXAMPLES_DIR=%FWDIR%examples set BAGEL_DIR=%FWDIR%bagel -set PYSPARK_DIR=%FWDIR%pyspark +set PYSPARK_DIR=%FWDIR%python rem Build up classpath set CLASSPATH=%SPARK_CLASSPATH%;%MESOS_CLASSPATH%;%FWDIR%conf;%CORE_DIR%\target\scala-%SCALA_VERSION%\classes From ce9f1bbe20eff794cd1d588dc88f109d32588cfe Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Tue, 1 Jan 2013 21:25:49 -0800 Subject: [PATCH 40/85] Add `pyspark` script to replace the other scripts. Expand the PySpark programming guide. --- docs/python-programming-guide.md | 49 ++++++++++++++++++++++++++++---- docs/quick-start.md | 4 +-- run-pyspark => pyspark | 4 +++ pyspark-shell | 3 -- python/pyspark/shell.py | 36 +++++++---------------- python/run-tests | 9 ++++++ 6 files changed, 69 insertions(+), 36 deletions(-) rename run-pyspark => pyspark (80%) delete mode 100755 pyspark-shell create mode 100755 python/run-tests diff --git a/docs/python-programming-guide.md b/docs/python-programming-guide.md index d88d4eb42d..d963551296 100644 --- a/docs/python-programming-guide.md +++ b/docs/python-programming-guide.md @@ -24,6 +24,35 @@ There are a few key differences between the Python and Scala APIs: - `sample` - `sort` +In PySpark, RDDs support the same methods as their Scala counterparts but take Python functions and return Python collection types. +Short functions can be passed to RDD methods using Python's [`lambda`](http://www.diveintopython.net/power_of_introspection/lambda_functions.html) syntax: + +{% highlight python %} +logData = sc.textFile(logFile).cache() +errors = logData.filter(lambda s: 'ERROR' in s.split()) +{% endhighlight %} + +You can also pass functions that are defined using the `def` keyword; this is useful for more complicated functions that cannot be expressed using `lambda`: + +{% highlight python %} +def is_error(line): + return 'ERROR' in line.split() +errors = logData.filter(is_error) +{% endhighlight %} + +Functions can access objects in enclosing scopes, although modifications to those objects within RDD methods will not be propagated to other tasks: + +{% highlight python %} +error_keywords = ["Exception", "Error"] +def is_error(line): + words = line.split() + return any(keyword in words for keyword in error_keywords) +errors = logData.filter(is_error) +{% endhighlight %} + +PySpark will automatically ship these functions to workers, along with any objects that they reference. +Instances of classes will be serialized and shipped to workers by PySpark, but classes themselves cannot be automatically distributed to workers. +The [Standalone Use](#standalone-use) section describes how to ship code dependencies to workers. # Installing and Configuring PySpark @@ -34,13 +63,14 @@ By default, PySpark's scripts will run programs using `python`; an alternate Pyt All of PySpark's library dependencies, including [Py4J](http://py4j.sourceforge.net/), are bundled with PySpark and automatically imported. -Standalone PySpark jobs should be run using the `run-pyspark` script, which automatically configures the Java and Python environmnt using the settings in `conf/spark-env.sh`. +Standalone PySpark jobs should be run using the `pyspark` script, which automatically configures the Java and Python environment using the settings in `conf/spark-env.sh`. The script automatically adds the `pyspark` package to the `PYTHONPATH`. # Interactive Use -PySpark's `pyspark-shell` script provides a simple way to learn the API: +The `pyspark` script launches a Python interpreter that is configured to run PySpark jobs. +When run without any input files, `pyspark` launches a shell that can be used explore data interactively, which is a simple way to learn the API: {% highlight python %} >>> words = sc.textFile("/usr/share/dict/words") @@ -48,9 +78,18 @@ PySpark's `pyspark-shell` script provides a simple way to learn the API: [u'spar', u'sparable', u'sparada', u'sparadrap', u'sparagrass'] {% endhighlight %} +By default, the `pyspark` shell creates SparkContext that runs jobs locally. +To connect to a non-local cluster, set the `MASTER` environment variable. +For example, to use the `pyspark` shell with a [standalone Spark cluster](spark-standalone.html): + +{% highlight shell %} +$ MASTER=spark://IP:PORT ./pyspark +{% endhighlight %} + + # Standalone Use -PySpark can also be used from standalone Python scripts by creating a SparkContext in the script and running the script using the `run-pyspark` script in the `pyspark` directory. +PySpark can also be used from standalone Python scripts by creating a SparkContext in your script and running the script using `pyspark`. The Quick Start guide includes a [complete example](quick-start.html#a-standalone-job-in-python) of a standalone Python job. Code dependencies can be deployed by listing them in the `pyFiles` option in the SparkContext constructor: @@ -65,8 +104,8 @@ Code dependencies can be added to an existing SparkContext using its `addPyFile( # Where to Go from Here -PySpark includes several sample programs using the Python API in `pyspark/examples`. -You can run them by passing the files to the `pyspark-run` script included in PySpark -- for example `./pyspark-run examples/wordcount.py`. +PySpark includes several sample programs using the Python API in `python/examples`. +You can run them by passing the files to the `pyspark` script -- for example `./pyspark python/examples/wordcount.py`. Each example program prints usage help when run without any arguments. We currently provide [API documentation](api/pyspark/index.html) for the Python API as Epydoc. diff --git a/docs/quick-start.md b/docs/quick-start.md index 8c25df5486..2c7cfbed25 100644 --- a/docs/quick-start.md +++ b/docs/quick-start.md @@ -258,11 +258,11 @@ We can pass Python functions to Spark, which are automatically serialized along For jobs that use custom classes or third-party libraries, we can add those code dependencies to SparkContext to ensure that they will be available on remote machines; this is described in more detail in the [Python programming guide](python-programming-guide). `SimpleJob` is simple enough that we do not need to specify any code dependencies. -We can run this job using the `run-pyspark` script in `$SPARK_HOME/pyspark`: +We can run this job using the `pyspark` script: {% highlight python %} $ cd $SPARK_HOME -$ ./pyspark/run-pyspark SimpleJob.py +$ ./pyspark SimpleJob.py ... Lines with a: 8422, Lines with b: 1836 {% endhighlight python %} diff --git a/run-pyspark b/pyspark similarity index 80% rename from run-pyspark rename to pyspark index deb0d708b3..9e89d51ba2 100755 --- a/run-pyspark +++ b/pyspark @@ -20,6 +20,10 @@ export PYSPARK_PYTHON # Add the PySpark classes to the Python path: export PYTHONPATH=$SPARK_HOME/python/:$PYTHONPATH +# Load the PySpark shell.py script when ./pyspark is used interactively: +export OLD_PYTHONSTARTUP=$PYTHONSTARTUP +export PYTHONSTARTUP=$FWDIR/python/pyspark/shell.py + # Launch with `scala` by default: if [[ "$SPARK_LAUNCH_WITH_SCALA" != "0" ]] ; then export SPARK_LAUNCH_WITH_SCALA=1 diff --git a/pyspark-shell b/pyspark-shell deleted file mode 100755 index 27aaac3a26..0000000000 --- a/pyspark-shell +++ /dev/null @@ -1,3 +0,0 @@ -#!/usr/bin/env bash -FWDIR="`dirname $0`" -exec $FWDIR/run-pyspark $FWDIR/python/pyspark/shell.py "$@" diff --git a/python/pyspark/shell.py b/python/pyspark/shell.py index bd39b0283f..7e6ad3aa76 100644 --- a/python/pyspark/shell.py +++ b/python/pyspark/shell.py @@ -1,33 +1,17 @@ """ An interactive shell. -""" -import optparse # I prefer argparse, but it's not included with Python < 2.7 -import code -import sys +This fle is designed to be launched as a PYTHONSTARTUP script. +""" +import os from pyspark.context import SparkContext -def main(master='local', ipython=False): - sc = SparkContext(master, 'PySparkShell') - user_ns = {'sc' : sc} - banner = "Spark context avaiable as sc." - if ipython: - import IPython - IPython.embed(user_ns=user_ns, banner2=banner) - else: - print banner - code.interact(local=user_ns) +sc = SparkContext(os.environ.get("MASTER", "local"), "PySparkShell") +print "Spark context avaiable as sc." - -if __name__ == '__main__': - usage = "usage: %prog [options] master" - parser = optparse.OptionParser(usage=usage) - parser.add_option("-i", "--ipython", help="Run IPython shell", - action="store_true") - (options, args) = parser.parse_args() - if len(sys.argv) > 1: - master = args[0] - else: - master = 'local' - main(master, options.ipython) +# The ./pyspark script stores the old PYTHONSTARTUP value in OLD_PYTHONSTARTUP, +# which allows us to execute the user's PYTHONSTARTUP file: +_pythonstartup = os.environ.get('OLD_PYTHONSTARTUP') +if _pythonstartup and os.path.isfile(_pythonstartup): + execfile(_pythonstartup) diff --git a/python/run-tests b/python/run-tests new file mode 100755 index 0000000000..da9e24cb1f --- /dev/null +++ b/python/run-tests @@ -0,0 +1,9 @@ +#!/usr/bin/env bash + +# Figure out where the Scala framework is installed +FWDIR="$(cd `dirname $0`; cd ../; pwd)" + +$FWDIR/pyspark pyspark/rdd.py +$FWDIR/pyspark -m doctest pyspark/broadcast.py + +# TODO: in the long-run, it would be nice to use a test runner like `nose`. From 33beba39656fc64984db09a82fc69ca4edcc02d4 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 3 Jan 2013 14:52:21 -0800 Subject: [PATCH 41/85] Change PySpark RDD.take() to not call iterator(). --- core/src/main/scala/spark/api/python/PythonRDD.scala | 4 ++++ python/pyspark/context.py | 1 + python/pyspark/rdd.py | 11 +++++------ 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index cf60d14f03..79d824d494 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -10,6 +10,7 @@ import spark.api.java.{JavaSparkContext, JavaPairRDD, JavaRDD} import spark.broadcast.Broadcast import spark._ import spark.rdd.PipedRDD +import java.util private[spark] class PythonRDD[T: ClassManifest]( @@ -216,6 +217,9 @@ private[spark] object PythonRDD { } file.close() } + + def takePartition[T](rdd: RDD[T], partition: Int): java.util.Iterator[T] = + rdd.context.runJob(rdd, ((x: Iterator[T]) => x), Seq(partition), true).head } private object Pickle { diff --git a/python/pyspark/context.py b/python/pyspark/context.py index 6172d69dcf..4439356c1f 100644 --- a/python/pyspark/context.py +++ b/python/pyspark/context.py @@ -21,6 +21,7 @@ class SparkContext(object): jvm = gateway.jvm _readRDDFromPickleFile = jvm.PythonRDD.readRDDFromPickleFile _writeIteratorToPickleFile = jvm.PythonRDD.writeIteratorToPickleFile + _takePartition = jvm.PythonRDD.takePartition def __init__(self, master, jobName, sparkHome=None, pyFiles=None, environment=None, batchSize=1024): diff --git a/python/pyspark/rdd.py b/python/pyspark/rdd.py index cbffb6cc1f..4ba417b2a2 100644 --- a/python/pyspark/rdd.py +++ b/python/pyspark/rdd.py @@ -328,18 +328,17 @@ class RDD(object): a lot of partitions are required. In that case, use L{collect} to get the whole RDD instead. - >>> sc.parallelize([2, 3, 4, 5, 6]).take(2) + >>> sc.parallelize([2, 3, 4, 5, 6]).cache().take(2) [2, 3] >>> sc.parallelize([2, 3, 4, 5, 6]).take(10) [2, 3, 4, 5, 6] """ items = [] - splits = self._jrdd.splits() - taskContext = self.ctx.jvm.spark.TaskContext(0, 0, 0) - while len(items) < num and splits: - split = splits.pop(0) - iterator = self._jrdd.iterator(split, taskContext) + for partition in range(self._jrdd.splits().size()): + iterator = self.ctx._takePartition(self._jrdd.rdd(), partition) items.extend(self._collect_iterator_through_file(iterator)) + if len(items) >= num: + break return items[:num] def first(self): From 8d57c78c83f74e45ce3c119e2e3915d5eac264e7 Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Sat, 5 Jan 2013 10:54:05 -0600 Subject: [PATCH 42/85] Add PairRDDFunctions.keys and values. --- core/src/main/scala/spark/PairRDDFunctions.scala | 10 ++++++++++ core/src/test/scala/spark/ShuffleSuite.scala | 7 +++++++ 2 files changed, 17 insertions(+) diff --git a/core/src/main/scala/spark/PairRDDFunctions.scala b/core/src/main/scala/spark/PairRDDFunctions.scala index 413c944a66..ce48cea903 100644 --- a/core/src/main/scala/spark/PairRDDFunctions.scala +++ b/core/src/main/scala/spark/PairRDDFunctions.scala @@ -615,6 +615,16 @@ class PairRDDFunctions[K: ClassManifest, V: ClassManifest]( writer.cleanup() } + /** + * Return an RDD with the keys of each tuple. + */ + def keys: RDD[K] = self.map(_._1) + + /** + * Return an RDD with the values of each tuple. + */ + def values: RDD[V] = self.map(_._2) + private[spark] def getKeyClass() = implicitly[ClassManifest[K]].erasure private[spark] def getValueClass() = implicitly[ClassManifest[V]].erasure diff --git a/core/src/test/scala/spark/ShuffleSuite.scala b/core/src/test/scala/spark/ShuffleSuite.scala index 8170100f1d..5a867016f2 100644 --- a/core/src/test/scala/spark/ShuffleSuite.scala +++ b/core/src/test/scala/spark/ShuffleSuite.scala @@ -216,6 +216,13 @@ class ShuffleSuite extends FunSuite with ShouldMatchers with BeforeAndAfter { // Test that a shuffle on the file works, because this used to be a bug assert(file.map(line => (line, 1)).reduceByKey(_ + _).collect().toList === Nil) } + + test("kesy and values") { + sc = new SparkContext("local", "test") + val rdd = sc.parallelize(Array((1, "a"), (2, "b"))) + assert(rdd.keys.collect().toList === List(1, 2)) + assert(rdd.values.collect().toList === List("a", "b")) + } } object ShuffleSuite { From f4e6b9361ffeec1018d5834f09db9fd86f2ba7bd Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Fri, 4 Jan 2013 22:43:22 -0600 Subject: [PATCH 43/85] Add RDD.collect(PartialFunction). --- core/src/main/scala/spark/RDD.scala | 7 +++++++ core/src/test/scala/spark/RDDSuite.scala | 1 + 2 files changed, 8 insertions(+) diff --git a/core/src/main/scala/spark/RDD.scala b/core/src/main/scala/spark/RDD.scala index 7e38583391..5163c80134 100644 --- a/core/src/main/scala/spark/RDD.scala +++ b/core/src/main/scala/spark/RDD.scala @@ -329,6 +329,13 @@ abstract class RDD[T: ClassManifest](@transient sc: SparkContext) extends Serial */ def toArray(): Array[T] = collect() + /** + * Return an RDD that contains all matching values by applying `f`. + */ + def collect[U: ClassManifest](f: PartialFunction[T, U]): RDD[U] = { + filter(f.isDefinedAt).map(f) + } + /** * Reduces the elements of this RDD using the specified associative binary operator. */ diff --git a/core/src/test/scala/spark/RDDSuite.scala b/core/src/test/scala/spark/RDDSuite.scala index 45e6c5f840..872b06fd08 100644 --- a/core/src/test/scala/spark/RDDSuite.scala +++ b/core/src/test/scala/spark/RDDSuite.scala @@ -35,6 +35,7 @@ class RDDSuite extends FunSuite with BeforeAndAfter { assert(nums.flatMap(x => 1 to x).collect().toList === List(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)) assert(nums.union(nums).collect().toList === List(1, 2, 3, 4, 1, 2, 3, 4)) assert(nums.glom().map(_.toList).collect().toList === List(List(1, 2), List(3, 4))) + assert(nums.collect({ case i if i >= 3 => i.toString }).collect().toList === List("3", "4")) val partitionSums = nums.mapPartitions(iter => Iterator(iter.reduceLeft(_ + _))) assert(partitionSums.collect().toList === List(3, 7)) From 6a0db3b449a829f3e5cdf7229f6ee564268be1df Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Sat, 5 Jan 2013 12:56:17 -0600 Subject: [PATCH 44/85] Fix typo. --- core/src/test/scala/spark/ShuffleSuite.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/test/scala/spark/ShuffleSuite.scala b/core/src/test/scala/spark/ShuffleSuite.scala index 5a867016f2..bebb8ebe86 100644 --- a/core/src/test/scala/spark/ShuffleSuite.scala +++ b/core/src/test/scala/spark/ShuffleSuite.scala @@ -217,7 +217,7 @@ class ShuffleSuite extends FunSuite with ShouldMatchers with BeforeAndAfter { assert(file.map(line => (line, 1)).reduceByKey(_ + _).collect().toList === Nil) } - test("kesy and values") { + test("keys and values") { sc = new SparkContext("local", "test") val rdd = sc.parallelize(Array((1, "a"), (2, "b"))) assert(rdd.keys.collect().toList === List(1, 2)) From 1fdb6946b5d076ed0f1b4d2bca2a20b6cd22cbc3 Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Sat, 5 Jan 2013 13:07:59 -0600 Subject: [PATCH 45/85] Add RDD.tupleBy. --- core/src/main/scala/spark/RDD.scala | 7 +++++++ core/src/test/scala/spark/RDDSuite.scala | 1 + 2 files changed, 8 insertions(+) diff --git a/core/src/main/scala/spark/RDD.scala b/core/src/main/scala/spark/RDD.scala index 7e38583391..7aa4b0a173 100644 --- a/core/src/main/scala/spark/RDD.scala +++ b/core/src/main/scala/spark/RDD.scala @@ -510,6 +510,13 @@ abstract class RDD[T: ClassManifest](@transient sc: SparkContext) extends Serial .saveAsSequenceFile(path) } + /** + * Tuples the elements of this RDD by applying `f`. + */ + def tupleBy[K](f: T => K): RDD[(K, T)] = { + map(x => (f(x), x)) + } + /** A private method for tests, to look at the contents of each partition */ private[spark] def collectPartitions(): Array[Array[T]] = { sc.runJob(this, (iter: Iterator[T]) => iter.toArray) diff --git a/core/src/test/scala/spark/RDDSuite.scala b/core/src/test/scala/spark/RDDSuite.scala index 45e6c5f840..7832884224 100644 --- a/core/src/test/scala/spark/RDDSuite.scala +++ b/core/src/test/scala/spark/RDDSuite.scala @@ -35,6 +35,7 @@ class RDDSuite extends FunSuite with BeforeAndAfter { assert(nums.flatMap(x => 1 to x).collect().toList === List(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)) assert(nums.union(nums).collect().toList === List(1, 2, 3, 4, 1, 2, 3, 4)) assert(nums.glom().map(_.toList).collect().toList === List(List(1, 2), List(3, 4))) + assert(nums.tupleBy(_.toString).collect().toList === List(("1", 1), ("2", 2), ("3", 3), ("4", 4))) val partitionSums = nums.mapPartitions(iter => Iterator(iter.reduceLeft(_ + _))) assert(partitionSums.collect().toList === List(3, 7)) From 86af64b0a6fde5a6418727a77b43bdfeda1b81cd Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Sat, 5 Jan 2013 20:54:08 -0500 Subject: [PATCH 46/85] Fix Accumulators in Java, and add a test for them --- core/src/main/scala/spark/Accumulators.scala | 18 +++++++- core/src/main/scala/spark/SparkContext.scala | 7 +-- .../spark/api/java/JavaSparkContext.scala | 23 ++++++---- core/src/test/scala/spark/JavaAPISuite.java | 44 +++++++++++++++++++ 4 files changed, 79 insertions(+), 13 deletions(-) diff --git a/core/src/main/scala/spark/Accumulators.scala b/core/src/main/scala/spark/Accumulators.scala index bacd0ace37..6280f25391 100644 --- a/core/src/main/scala/spark/Accumulators.scala +++ b/core/src/main/scala/spark/Accumulators.scala @@ -38,14 +38,28 @@ class Accumulable[R, T] ( */ def += (term: T) { value_ = param.addAccumulator(value_, term) } + /** + * Add more data to this accumulator / accumulable + * @param term the data to add + */ + def add(term: T) { value_ = param.addAccumulator(value_, term) } + /** * Merge two accumulable objects together - * + * * Normally, a user will not want to use this version, but will instead call `+=`. - * @param term the other Accumulable that will get merged with this + * @param term the other `R` that will get merged with this */ def ++= (term: R) { value_ = param.addInPlace(value_, term)} + /** + * Merge two accumulable objects together + * + * Normally, a user will not want to use this version, but will instead call `add`. + * @param term the other `R` that will get merged with this + */ + def merge(term: R) { value_ = param.addInPlace(value_, term)} + /** * Access the accumulator's current value; only allowed on master. */ diff --git a/core/src/main/scala/spark/SparkContext.scala b/core/src/main/scala/spark/SparkContext.scala index 4fd81bc63b..bbf8272eb3 100644 --- a/core/src/main/scala/spark/SparkContext.scala +++ b/core/src/main/scala/spark/SparkContext.scala @@ -382,11 +382,12 @@ class SparkContext( new Accumulator(initialValue, param) /** - * Create an [[spark.Accumulable]] shared variable, with a `+=` method + * Create an [[spark.Accumulable]] shared variable, to which tasks can add values with `+=`. + * Only the master can access the accumuable's `value`. * @tparam T accumulator type * @tparam R type that can be added to the accumulator */ - def accumulable[T,R](initialValue: T)(implicit param: AccumulableParam[T,R]) = + def accumulable[T, R](initialValue: T)(implicit param: AccumulableParam[T, R]) = new Accumulable(initialValue, param) /** @@ -404,7 +405,7 @@ class SparkContext( * Broadcast a read-only variable to the cluster, returning a [[spark.Broadcast]] object for * reading it in distributed functions. The variable will be sent to each cluster only once. */ - def broadcast[T](value: T) = env.broadcastManager.newBroadcast[T] (value, isLocal) + def broadcast[T](value: T) = env.broadcastManager.newBroadcast[T](value, isLocal) /** * Add a file to be downloaded into the working directory of this Spark job on every node. diff --git a/core/src/main/scala/spark/api/java/JavaSparkContext.scala b/core/src/main/scala/spark/api/java/JavaSparkContext.scala index b7725313c4..bf9ad7a200 100644 --- a/core/src/main/scala/spark/api/java/JavaSparkContext.scala +++ b/core/src/main/scala/spark/api/java/JavaSparkContext.scala @@ -10,7 +10,7 @@ import org.apache.hadoop.mapred.InputFormat import org.apache.hadoop.mapred.JobConf import org.apache.hadoop.mapreduce.{InputFormat => NewInputFormat} -import spark.{Accumulator, AccumulatorParam, RDD, SparkContext} +import spark.{Accumulable, AccumulableParam, Accumulator, AccumulatorParam, RDD, SparkContext} import spark.SparkContext.IntAccumulatorParam import spark.SparkContext.DoubleAccumulatorParam import spark.broadcast.Broadcast @@ -265,25 +265,32 @@ class JavaSparkContext(val sc: SparkContext) extends JavaSparkContextVarargsWork /** * Create an [[spark.Accumulator]] integer variable, which tasks can "add" values - * to using the `+=` method. Only the master can access the accumulator's `value`. + * to using the `add` method. Only the master can access the accumulator's `value`. */ - def intAccumulator(initialValue: Int): Accumulator[Int] = - sc.accumulator(initialValue)(IntAccumulatorParam) + def intAccumulator(initialValue: Int): Accumulator[java.lang.Integer] = + sc.accumulator(initialValue)(IntAccumulatorParam).asInstanceOf[Accumulator[java.lang.Integer]] /** * Create an [[spark.Accumulator]] double variable, which tasks can "add" values - * to using the `+=` method. Only the master can access the accumulator's `value`. + * to using the `add` method. Only the master can access the accumulator's `value`. */ - def doubleAccumulator(initialValue: Double): Accumulator[Double] = - sc.accumulator(initialValue)(DoubleAccumulatorParam) + def doubleAccumulator(initialValue: Double): Accumulator[java.lang.Double] = + sc.accumulator(initialValue)(DoubleAccumulatorParam).asInstanceOf[Accumulator[java.lang.Double]] /** * Create an [[spark.Accumulator]] variable of a given type, which tasks can "add" values - * to using the `+=` method. Only the master can access the accumulator's `value`. + * to using the `add` method. Only the master can access the accumulator's `value`. */ def accumulator[T](initialValue: T, accumulatorParam: AccumulatorParam[T]): Accumulator[T] = sc.accumulator(initialValue)(accumulatorParam) + /** + * Create an [[spark.Accumulable]] shared variable of the given type, to which tasks can + * "add" values with `add`. Only the master can access the accumuable's `value`. + */ + def accumulable[T, R](initialValue: T, param: AccumulableParam[T, R]): Accumulable[T, R] = + sc.accumulable(initialValue)(param) + /** * Broadcast a read-only variable to the cluster, returning a [[spark.Broadcast]] object for * reading it in distributed functions. The variable will be sent to each cluster only once. diff --git a/core/src/test/scala/spark/JavaAPISuite.java b/core/src/test/scala/spark/JavaAPISuite.java index 33d5fc2d89..b99e790093 100644 --- a/core/src/test/scala/spark/JavaAPISuite.java +++ b/core/src/test/scala/spark/JavaAPISuite.java @@ -581,4 +581,48 @@ public class JavaAPISuite implements Serializable { JavaPairRDD zipped = rdd.zip(doubles); zipped.count(); } + + @Test + public void accumulators() { + JavaRDD rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5)); + + final Accumulator intAccum = sc.intAccumulator(10); + rdd.foreach(new VoidFunction() { + public void call(Integer x) { + intAccum.add(x); + } + }); + Assert.assertEquals((Integer) 25, intAccum.value()); + + final Accumulator doubleAccum = sc.doubleAccumulator(10.0); + rdd.foreach(new VoidFunction() { + public void call(Integer x) { + doubleAccum.add((double) x); + } + }); + Assert.assertEquals((Double) 25.0, doubleAccum.value()); + + // Try a custom accumulator type + AccumulatorParam floatAccumulatorParam = new AccumulatorParam() { + public Float addInPlace(Float r, Float t) { + return r + t; + } + + public Float addAccumulator(Float r, Float t) { + return r + t; + } + + public Float zero(Float initialValue) { + return 0.0f; + } + }; + + final Accumulator floatAccum = sc.accumulator((Float) 10.0f, floatAccumulatorParam); + rdd.foreach(new VoidFunction() { + public void call(Integer x) { + floatAccum.add((float) x); + } + }); + Assert.assertEquals((Float) 25.0f, floatAccum.value()); + } } From 0982572519655354b10987de4f68e29b8331bd2a Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Sat, 5 Jan 2013 22:11:28 -0500 Subject: [PATCH 47/85] Add methods called just 'accumulator' for int/double in Java API --- .../scala/spark/api/java/JavaSparkContext.scala | 13 +++++++++++++ core/src/test/scala/spark/JavaAPISuite.java | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/core/src/main/scala/spark/api/java/JavaSparkContext.scala b/core/src/main/scala/spark/api/java/JavaSparkContext.scala index bf9ad7a200..88ab2846be 100644 --- a/core/src/main/scala/spark/api/java/JavaSparkContext.scala +++ b/core/src/main/scala/spark/api/java/JavaSparkContext.scala @@ -277,6 +277,19 @@ class JavaSparkContext(val sc: SparkContext) extends JavaSparkContextVarargsWork def doubleAccumulator(initialValue: Double): Accumulator[java.lang.Double] = sc.accumulator(initialValue)(DoubleAccumulatorParam).asInstanceOf[Accumulator[java.lang.Double]] + /** + * Create an [[spark.Accumulator]] integer variable, which tasks can "add" values + * to using the `add` method. Only the master can access the accumulator's `value`. + */ + def accumulator(initialValue: Int): Accumulator[java.lang.Integer] = intAccumulator(initialValue) + + /** + * Create an [[spark.Accumulator]] double variable, which tasks can "add" values + * to using the `add` method. Only the master can access the accumulator's `value`. + */ + def accumulator(initialValue: Double): Accumulator[java.lang.Double] = + doubleAccumulator(initialValue) + /** * Create an [[spark.Accumulator]] variable of a given type, which tasks can "add" values * to using the `add` method. Only the master can access the accumulator's `value`. diff --git a/core/src/test/scala/spark/JavaAPISuite.java b/core/src/test/scala/spark/JavaAPISuite.java index b99e790093..912f8de05d 100644 --- a/core/src/test/scala/spark/JavaAPISuite.java +++ b/core/src/test/scala/spark/JavaAPISuite.java @@ -586,7 +586,7 @@ public class JavaAPISuite implements Serializable { public void accumulators() { JavaRDD rdd = sc.parallelize(Arrays.asList(1, 2, 3, 4, 5)); - final Accumulator intAccum = sc.intAccumulator(10); + final Accumulator intAccum = sc.accumulator(10); rdd.foreach(new VoidFunction() { public void call(Integer x) { intAccum.add(x); @@ -594,7 +594,7 @@ public class JavaAPISuite implements Serializable { }); Assert.assertEquals((Integer) 25, intAccum.value()); - final Accumulator doubleAccum = sc.doubleAccumulator(10.0); + final Accumulator doubleAccum = sc.accumulator(10.0); rdd.foreach(new VoidFunction() { public void call(Integer x) { doubleAccum.add((double) x); From 8fd3a70c188182105f81f5143ec65e74663582d5 Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Sat, 5 Jan 2013 22:46:45 -0500 Subject: [PATCH 48/85] Add PairRDD.keys() and values() to Java API --- core/src/main/scala/spark/api/java/JavaPairRDD.scala | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/core/src/main/scala/spark/api/java/JavaPairRDD.scala b/core/src/main/scala/spark/api/java/JavaPairRDD.scala index 5c2be534ff..8ce32e0e2f 100644 --- a/core/src/main/scala/spark/api/java/JavaPairRDD.scala +++ b/core/src/main/scala/spark/api/java/JavaPairRDD.scala @@ -471,6 +471,16 @@ class JavaPairRDD[K, V](val rdd: RDD[(K, V)])(implicit val kManifest: ClassManif implicit def toOrdered(x: K): Ordered[K] = new KeyOrdering(x) fromRDD(new OrderedRDDFunctions(rdd).sortByKey(ascending)) } + + /** + * Return an RDD with the keys of each tuple. + */ + def keys(): JavaRDD[K] = JavaRDD.fromRDD[K](rdd.map(_._1)) + + /** + * Return an RDD with the values of each tuple. + */ + def values(): JavaRDD[V] = JavaRDD.fromRDD[V](rdd.map(_._2)) } object JavaPairRDD { From 8dc06069fe2330c3ee0fcaaeb0ae6e627a5887c3 Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Sun, 6 Jan 2013 15:21:45 -0600 Subject: [PATCH 49/85] Rename RDD.tupleBy to keyBy. --- core/src/main/scala/spark/RDD.scala | 4 ++-- core/src/test/scala/spark/RDDSuite.scala | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/core/src/main/scala/spark/RDD.scala b/core/src/main/scala/spark/RDD.scala index 7aa4b0a173..5ce524c0e7 100644 --- a/core/src/main/scala/spark/RDD.scala +++ b/core/src/main/scala/spark/RDD.scala @@ -511,9 +511,9 @@ abstract class RDD[T: ClassManifest](@transient sc: SparkContext) extends Serial } /** - * Tuples the elements of this RDD by applying `f`. + * Creates tuples of the elements in this RDD by applying `f`. */ - def tupleBy[K](f: T => K): RDD[(K, T)] = { + def keyBy[K](f: T => K): RDD[(K, T)] = { map(x => (f(x), x)) } diff --git a/core/src/test/scala/spark/RDDSuite.scala b/core/src/test/scala/spark/RDDSuite.scala index 7832884224..77bff8aba1 100644 --- a/core/src/test/scala/spark/RDDSuite.scala +++ b/core/src/test/scala/spark/RDDSuite.scala @@ -35,7 +35,7 @@ class RDDSuite extends FunSuite with BeforeAndAfter { assert(nums.flatMap(x => 1 to x).collect().toList === List(1, 1, 2, 1, 2, 3, 1, 2, 3, 4)) assert(nums.union(nums).collect().toList === List(1, 2, 3, 4, 1, 2, 3, 4)) assert(nums.glom().map(_.toList).collect().toList === List(List(1, 2), List(3, 4))) - assert(nums.tupleBy(_.toString).collect().toList === List(("1", 1), ("2", 2), ("3", 3), ("4", 4))) + assert(nums.keyBy(_.toString).collect().toList === List(("1", 1), ("2", 2), ("3", 3), ("4", 4))) val partitionSums = nums.mapPartitions(iter => Iterator(iter.reduceLeft(_ + _))) assert(partitionSums.collect().toList === List(3, 7)) From 9c32f300fb4151a2b563bf3d2e46469722e016e1 Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Mon, 7 Jan 2013 16:50:23 -0500 Subject: [PATCH 50/85] Add Accumulable.setValue for easier use in Java --- core/src/main/scala/spark/Accumulators.scala | 20 +++++++++++++++----- core/src/test/scala/spark/JavaAPISuite.java | 4 ++++ 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/core/src/main/scala/spark/Accumulators.scala b/core/src/main/scala/spark/Accumulators.scala index 6280f25391..b644aba5f8 100644 --- a/core/src/main/scala/spark/Accumulators.scala +++ b/core/src/main/scala/spark/Accumulators.scala @@ -63,9 +63,12 @@ class Accumulable[R, T] ( /** * Access the accumulator's current value; only allowed on master. */ - def value = { - if (!deserialized) value_ - else throw new UnsupportedOperationException("Can't read accumulator value in task") + def value: R = { + if (!deserialized) { + value_ + } else { + throw new UnsupportedOperationException("Can't read accumulator value in task") + } } /** @@ -82,10 +85,17 @@ class Accumulable[R, T] ( /** * Set the accumulator's value; only allowed on master. */ - def value_= (r: R) { - if (!deserialized) value_ = r + def value_= (newValue: R) { + if (!deserialized) value_ = newValue else throw new UnsupportedOperationException("Can't assign accumulator value in task") } + + /** + * Set the accumulator's value; only allowed on master + */ + def setValue(newValue: R) { + this.value = newValue + } // Called by Java when deserializing an object private def readObject(in: ObjectInputStream) { diff --git a/core/src/test/scala/spark/JavaAPISuite.java b/core/src/test/scala/spark/JavaAPISuite.java index 912f8de05d..0817d1146c 100644 --- a/core/src/test/scala/spark/JavaAPISuite.java +++ b/core/src/test/scala/spark/JavaAPISuite.java @@ -624,5 +624,9 @@ public class JavaAPISuite implements Serializable { } }); Assert.assertEquals((Float) 25.0f, floatAccum.value()); + + // Test the setValue method + floatAccum.setValue(5.0f); + Assert.assertEquals((Float) 5.0f, floatAccum.value()); } } From f8d579a0c05b7d29b59e541b483ded471d14ec17 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Thu, 27 Dec 2012 13:30:07 -0800 Subject: [PATCH 51/85] Remove dependencies on sun jvm classes. Instead use reflection to infer HotSpot options and total physical memory size --- core/src/main/scala/spark/SizeEstimator.scala | 13 ++++++++--- .../spark/deploy/worker/WorkerArguments.scala | 22 ++++++++++++++++--- 2 files changed, 29 insertions(+), 6 deletions(-) diff --git a/core/src/main/scala/spark/SizeEstimator.scala b/core/src/main/scala/spark/SizeEstimator.scala index 7c3e8640e9..d4e1157250 100644 --- a/core/src/main/scala/spark/SizeEstimator.scala +++ b/core/src/main/scala/spark/SizeEstimator.scala @@ -9,7 +9,6 @@ import java.util.Random import javax.management.MBeanServer import java.lang.management.ManagementFactory -import com.sun.management.HotSpotDiagnosticMXBean import scala.collection.mutable.ArrayBuffer @@ -76,12 +75,20 @@ private[spark] object SizeEstimator extends Logging { if (System.getProperty("spark.test.useCompressedOops") != null) { return System.getProperty("spark.test.useCompressedOops").toBoolean } + try { val hotSpotMBeanName = "com.sun.management:type=HotSpotDiagnostic" val server = ManagementFactory.getPlatformMBeanServer() + + // NOTE: This should throw an exception in non-Sun JVMs + val hotSpotMBeanClass = Class.forName("com.sun.management.HotSpotDiagnosticMXBean") + val getVMMethod = hotSpotMBeanClass.getDeclaredMethod("getVMOption", + Class.forName("java.lang.String")) + val bean = ManagementFactory.newPlatformMXBeanProxy(server, - hotSpotMBeanName, classOf[HotSpotDiagnosticMXBean]) - return bean.getVMOption("UseCompressedOops").getValue.toBoolean + hotSpotMBeanName, hotSpotMBeanClass) + // TODO: We could use reflection on the VMOption returned ? + return getVMMethod.invoke(bean, "UseCompressedOops").toString.contains("true") } catch { case e: Exception => { // Guess whether they've enabled UseCompressedOops based on whether maxMemory < 32 GB diff --git a/core/src/main/scala/spark/deploy/worker/WorkerArguments.scala b/core/src/main/scala/spark/deploy/worker/WorkerArguments.scala index 340920025b..37524a7c82 100644 --- a/core/src/main/scala/spark/deploy/worker/WorkerArguments.scala +++ b/core/src/main/scala/spark/deploy/worker/WorkerArguments.scala @@ -104,9 +104,25 @@ private[spark] class WorkerArguments(args: Array[String]) { } def inferDefaultMemory(): Int = { - val bean = ManagementFactory.getOperatingSystemMXBean - .asInstanceOf[com.sun.management.OperatingSystemMXBean] - val totalMb = (bean.getTotalPhysicalMemorySize / 1024 / 1024).toInt + val ibmVendor = System.getProperty("java.vendor").contains("IBM") + var totalMb = 0 + try { + val bean = ManagementFactory.getOperatingSystemMXBean() + if (ibmVendor) { + val beanClass = Class.forName("com.ibm.lang.management.OperatingSystemMXBean") + val method = beanClass.getDeclaredMethod("getTotalPhysicalMemory") + totalMb = (method.invoke(bean).asInstanceOf[Long] / 1024 / 1024).toInt + } else { + val beanClass = Class.forName("com.sun.management.OperatingSystemMXBean") + val method = beanClass.getDeclaredMethod("getTotalPhysicalMemorySize") + totalMb = (method.invoke(bean).asInstanceOf[Long] / 1024 / 1024).toInt + } + } catch { + case e: Exception => { + totalMb = 2*1024 + System.out.println("Failed to get total physical memory. Using " + totalMb + " MB") + } + } // Leave out 1 GB for the operating system, but don't return a negative memory size math.max(totalMb - 1024, 512) } From aed368a970bbaee4bdf297ba3f6f1b0fa131452c Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Sat, 29 Dec 2012 16:23:43 -0800 Subject: [PATCH 52/85] Update Hadoop dependency to 1.0.3 as 0.20 has Sun specific dependencies. Also fix SequenceFileRDDFunctions to pick the right type conversion across Hadoop versions --- core/src/main/scala/spark/SequenceFileRDDFunctions.scala | 8 +++++++- project/SparkBuild.scala | 2 +- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/core/src/main/scala/spark/SequenceFileRDDFunctions.scala b/core/src/main/scala/spark/SequenceFileRDDFunctions.scala index a34aee69c1..6b4a11d6d3 100644 --- a/core/src/main/scala/spark/SequenceFileRDDFunctions.scala +++ b/core/src/main/scala/spark/SequenceFileRDDFunctions.scala @@ -42,7 +42,13 @@ class SequenceFileRDDFunctions[K <% Writable: ClassManifest, V <% Writable : Cla if (classOf[Writable].isAssignableFrom(classManifest[T].erasure)) { classManifest[T].erasure } else { - implicitly[T => Writable].getClass.getMethods()(0).getReturnType + // We get the type of the Writable class by looking at the apply method which converts + // from T to Writable. Since we have two apply methods we filter out the one which + // is of the form "java.lang.Object apply(java.lang.Object)" + implicitly[T => Writable].getClass.getDeclaredMethods().filter( + m => m.getReturnType().toString != "java.lang.Object" && + m.getName() == "apply")(0).getReturnType + } // TODO: use something like WritableConverter to avoid reflection } diff --git a/project/SparkBuild.scala b/project/SparkBuild.scala index 842d0fa96b..7c7c33131a 100644 --- a/project/SparkBuild.scala +++ b/project/SparkBuild.scala @@ -10,7 +10,7 @@ import twirl.sbt.TwirlPlugin._ object SparkBuild extends Build { // Hadoop version to build against. For example, "0.20.2", "0.20.205.0", or // "1.0.3" for Apache releases, or "0.20.2-cdh3u5" for Cloudera Hadoop. - val HADOOP_VERSION = "0.20.205.0" + val HADOOP_VERSION = "1.0.3" val HADOOP_MAJOR_VERSION = "1" // For Hadoop 2 versions such as "2.0.0-mr1-cdh4.1.1", set the HADOOP_MAJOR_VERSION to "2" From 77d751731ccd06e161e3ef10540f8165d964282f Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Sat, 29 Dec 2012 18:28:00 -0800 Subject: [PATCH 53/85] Remove unused BoundedMemoryCache file and associated test case. --- .../main/scala/spark/BoundedMemoryCache.scala | 118 ------------------ .../scala/spark/BoundedMemoryCacheSuite.scala | 58 --------- 2 files changed, 176 deletions(-) delete mode 100644 core/src/main/scala/spark/BoundedMemoryCache.scala delete mode 100644 core/src/test/scala/spark/BoundedMemoryCacheSuite.scala diff --git a/core/src/main/scala/spark/BoundedMemoryCache.scala b/core/src/main/scala/spark/BoundedMemoryCache.scala deleted file mode 100644 index e8392a194f..0000000000 --- a/core/src/main/scala/spark/BoundedMemoryCache.scala +++ /dev/null @@ -1,118 +0,0 @@ -package spark - -import java.util.LinkedHashMap - -/** - * An implementation of Cache that estimates the sizes of its entries and attempts to limit its - * total memory usage to a fraction of the JVM heap. Objects' sizes are estimated using - * SizeEstimator, which has limitations; most notably, we will overestimate total memory used if - * some cache entries have pointers to a shared object. Nonetheless, this Cache should work well - * when most of the space is used by arrays of primitives or of simple classes. - */ -private[spark] class BoundedMemoryCache(maxBytes: Long) extends Cache with Logging { - logInfo("BoundedMemoryCache.maxBytes = " + maxBytes) - - def this() { - this(BoundedMemoryCache.getMaxBytes) - } - - private var currentBytes = 0L - private val map = new LinkedHashMap[(Any, Int), Entry](32, 0.75f, true) - - override def get(datasetId: Any, partition: Int): Any = { - synchronized { - val entry = map.get((datasetId, partition)) - if (entry != null) { - entry.value - } else { - null - } - } - } - - override def put(datasetId: Any, partition: Int, value: Any): CachePutResponse = { - val key = (datasetId, partition) - logInfo("Asked to add key " + key) - val size = estimateValueSize(key, value) - synchronized { - if (size > getCapacity) { - return CachePutFailure() - } else if (ensureFreeSpace(datasetId, size)) { - logInfo("Adding key " + key) - map.put(key, new Entry(value, size)) - currentBytes += size - logInfo("Number of entries is now " + map.size) - return CachePutSuccess(size) - } else { - logInfo("Didn't add key " + key + " because we would have evicted part of same dataset") - return CachePutFailure() - } - } - } - - override def getCapacity: Long = maxBytes - - /** - * Estimate sizeOf 'value' - */ - private def estimateValueSize(key: (Any, Int), value: Any) = { - val startTime = System.currentTimeMillis - val size = SizeEstimator.estimate(value.asInstanceOf[AnyRef]) - val timeTaken = System.currentTimeMillis - startTime - logInfo("Estimated size for key %s is %d".format(key, size)) - logInfo("Size estimation for key %s took %d ms".format(key, timeTaken)) - size - } - - /** - * Remove least recently used entries from the map until at least space bytes are free, in order - * to make space for a partition from the given dataset ID. If this cannot be done without - * evicting other data from the same dataset, returns false; otherwise, returns true. Assumes - * that a lock is held on the BoundedMemoryCache. - */ - private def ensureFreeSpace(datasetId: Any, space: Long): Boolean = { - logInfo("ensureFreeSpace(%s, %d) called with curBytes=%d, maxBytes=%d".format( - datasetId, space, currentBytes, maxBytes)) - val iter = map.entrySet.iterator // Will give entries in LRU order - while (maxBytes - currentBytes < space && iter.hasNext) { - val mapEntry = iter.next() - val (entryDatasetId, entryPartition) = mapEntry.getKey - if (entryDatasetId == datasetId) { - // Cannot make space without removing part of the same dataset, or a more recently used one - return false - } - reportEntryDropped(entryDatasetId, entryPartition, mapEntry.getValue) - currentBytes -= mapEntry.getValue.size - iter.remove() - } - return true - } - - protected def reportEntryDropped(datasetId: Any, partition: Int, entry: Entry) { - logInfo("Dropping key (%s, %d) of size %d to make space".format(datasetId, partition, entry.size)) - // TODO: remove BoundedMemoryCache - - val (keySpaceId, innerDatasetId) = datasetId.asInstanceOf[(Any, Any)] - innerDatasetId match { - case rddId: Int => - SparkEnv.get.cacheTracker.dropEntry(rddId, partition) - case broadcastUUID: java.util.UUID => - // TODO: Maybe something should be done if the broadcasted variable falls out of cache - case _ => - } - } -} - -// An entry in our map; stores a cached object and its size in bytes -private[spark] case class Entry(value: Any, size: Long) - -private[spark] object BoundedMemoryCache { - /** - * Get maximum cache capacity from system configuration - */ - def getMaxBytes: Long = { - val memoryFractionToUse = System.getProperty("spark.boundedMemoryCache.memoryFraction", "0.66").toDouble - (Runtime.getRuntime.maxMemory * memoryFractionToUse).toLong - } -} - diff --git a/core/src/test/scala/spark/BoundedMemoryCacheSuite.scala b/core/src/test/scala/spark/BoundedMemoryCacheSuite.scala deleted file mode 100644 index 37cafd1e8e..0000000000 --- a/core/src/test/scala/spark/BoundedMemoryCacheSuite.scala +++ /dev/null @@ -1,58 +0,0 @@ -package spark - -import org.scalatest.FunSuite -import org.scalatest.PrivateMethodTester -import org.scalatest.matchers.ShouldMatchers - -// TODO: Replace this with a test of MemoryStore -class BoundedMemoryCacheSuite extends FunSuite with PrivateMethodTester with ShouldMatchers { - test("constructor test") { - val cache = new BoundedMemoryCache(60) - expect(60)(cache.getCapacity) - } - - test("caching") { - // Set the arch to 64-bit and compressedOops to true to get a deterministic test-case - val oldArch = System.setProperty("os.arch", "amd64") - val oldOops = System.setProperty("spark.test.useCompressedOops", "true") - val initialize = PrivateMethod[Unit]('initialize) - SizeEstimator invokePrivate initialize() - - val cache = new BoundedMemoryCache(60) { - //TODO sorry about this, but there is not better way how to skip 'cacheTracker.dropEntry' - override protected def reportEntryDropped(datasetId: Any, partition: Int, entry: Entry) { - logInfo("Dropping key (%s, %d) of size %d to make space".format(datasetId, partition, entry.size)) - } - } - - // NOTE: The String class definition changed in JDK 7 to exclude the int fields count and length - // This means that the size of strings will be lesser by 8 bytes in JDK 7 compared to JDK 6. - // http://mail.openjdk.java.net/pipermail/core-libs-dev/2012-May/010257.html - // Work around to check for either. - - //should be OK - cache.put("1", 0, "Meh") should (equal (CachePutSuccess(56)) or equal (CachePutSuccess(48))) - - //we cannot add this to cache (there is not enough space in cache) & we cannot evict the only value from - //cache because it's from the same dataset - expect(CachePutFailure())(cache.put("1", 1, "Meh")) - - //should be OK, dataset '1' can be evicted from cache - cache.put("2", 0, "Meh") should (equal (CachePutSuccess(56)) or equal (CachePutSuccess(48))) - - //should fail, cache should obey it's capacity - expect(CachePutFailure())(cache.put("3", 0, "Very_long_and_useless_string")) - - if (oldArch != null) { - System.setProperty("os.arch", oldArch) - } else { - System.clearProperty("os.arch") - } - - if (oldOops != null) { - System.setProperty("spark.test.useCompressedOops", oldOops) - } else { - System.clearProperty("spark.test.useCompressedOops") - } - } -} From 55c66d365f76f3e5ecc6b850ba81c84b320f6772 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Mon, 7 Jan 2013 15:19:33 -0800 Subject: [PATCH 54/85] Use a dummy string class in Size Estimator tests to make it resistant to jdk versions --- .../test/scala/spark/SizeEstimatorSuite.scala | 33 ++++++++++++------- 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/core/src/test/scala/spark/SizeEstimatorSuite.scala b/core/src/test/scala/spark/SizeEstimatorSuite.scala index 17f366212b..bf3b2e1eed 100644 --- a/core/src/test/scala/spark/SizeEstimatorSuite.scala +++ b/core/src/test/scala/spark/SizeEstimatorSuite.scala @@ -20,6 +20,15 @@ class DummyClass4(val d: DummyClass3) { val x: Int = 0 } +object DummyString { + def apply(str: String) : DummyString = new DummyString(str.toArray) +} +class DummyString(val arr: Array[Char]) { + override val hashCode: Int = 0 + // JDK-7 has an extra hash32 field http://hg.openjdk.java.net/jdk7u/jdk7u6/jdk/rev/11987e85555f + @transient val hash32: Int = 0 +} + class SizeEstimatorSuite extends FunSuite with BeforeAndAfterAll with PrivateMethodTester with ShouldMatchers { @@ -50,10 +59,10 @@ class SizeEstimatorSuite // http://mail.openjdk.java.net/pipermail/core-libs-dev/2012-May/010257.html // Work around to check for either. test("strings") { - SizeEstimator.estimate("") should (equal (48) or equal (40)) - SizeEstimator.estimate("a") should (equal (56) or equal (48)) - SizeEstimator.estimate("ab") should (equal (56) or equal (48)) - SizeEstimator.estimate("abcdefgh") should (equal(64) or equal(56)) + SizeEstimator.estimate(DummyString("")) should (equal (48) or equal (40)) + SizeEstimator.estimate(DummyString("a")) should (equal (56) or equal (48)) + SizeEstimator.estimate(DummyString("ab")) should (equal (56) or equal (48)) + SizeEstimator.estimate(DummyString("abcdefgh")) should (equal(64) or equal(56)) } test("primitive arrays") { @@ -105,10 +114,10 @@ class SizeEstimatorSuite val initialize = PrivateMethod[Unit]('initialize) SizeEstimator invokePrivate initialize() - expect(40)(SizeEstimator.estimate("")) - expect(48)(SizeEstimator.estimate("a")) - expect(48)(SizeEstimator.estimate("ab")) - expect(56)(SizeEstimator.estimate("abcdefgh")) + expect(40)(SizeEstimator.estimate(DummyString(""))) + expect(48)(SizeEstimator.estimate(DummyString("a"))) + expect(48)(SizeEstimator.estimate(DummyString("ab"))) + expect(56)(SizeEstimator.estimate(DummyString("abcdefgh"))) resetOrClear("os.arch", arch) } @@ -124,10 +133,10 @@ class SizeEstimatorSuite val initialize = PrivateMethod[Unit]('initialize) SizeEstimator invokePrivate initialize() - SizeEstimator.estimate("") should (equal (64) or equal (56)) - SizeEstimator.estimate("a") should (equal (72) or equal (64)) - SizeEstimator.estimate("ab") should (equal (72) or equal (64)) - SizeEstimator.estimate("abcdefgh") should (equal (80) or equal (72)) + SizeEstimator.estimate(DummyString("")) should (equal (64) or equal (56)) + SizeEstimator.estimate(DummyString("a")) should (equal (72) or equal (64)) + SizeEstimator.estimate(DummyString("ab")) should (equal (72) or equal (64)) + SizeEstimator.estimate(DummyString("abcdefgh")) should (equal (80) or equal (72)) resetOrClear("os.arch", arch) resetOrClear("spark.test.useCompressedOops", oops) From fb3d4d5e85cd4b094411bb08a32ab50cc62dc151 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Mon, 7 Jan 2013 16:46:06 -0800 Subject: [PATCH 55/85] Make default hadoop version 1.0.3 in pom.xml --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index b33cee26b8..fe5b1d0ee4 100644 --- a/pom.xml +++ b/pom.xml @@ -489,7 +489,7 @@ org.apache.hadoop hadoop-core - 0.20.205.0 + 1.0.3 From b1336e2fe458b92dcf60dcd249c41c7bdcc8be6d Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Mon, 7 Jan 2013 17:00:32 -0800 Subject: [PATCH 56/85] Update expected size of strings to match our dummy string class --- .../test/scala/spark/SizeEstimatorSuite.scala | 31 ++++++++----------- 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/core/src/test/scala/spark/SizeEstimatorSuite.scala b/core/src/test/scala/spark/SizeEstimatorSuite.scala index bf3b2e1eed..e235ef2f67 100644 --- a/core/src/test/scala/spark/SizeEstimatorSuite.scala +++ b/core/src/test/scala/spark/SizeEstimatorSuite.scala @@ -3,7 +3,6 @@ package spark import org.scalatest.FunSuite import org.scalatest.BeforeAndAfterAll import org.scalatest.PrivateMethodTester -import org.scalatest.matchers.ShouldMatchers class DummyClass1 {} @@ -30,7 +29,7 @@ class DummyString(val arr: Array[Char]) { } class SizeEstimatorSuite - extends FunSuite with BeforeAndAfterAll with PrivateMethodTester with ShouldMatchers { + extends FunSuite with BeforeAndAfterAll with PrivateMethodTester { var oldArch: String = _ var oldOops: String = _ @@ -54,15 +53,13 @@ class SizeEstimatorSuite expect(48)(SizeEstimator.estimate(new DummyClass4(new DummyClass3))) } - // NOTE: The String class definition changed in JDK 7 to exclude the int fields count and length. - // This means that the size of strings will be lesser by 8 bytes in JDK 7 compared to JDK 6. - // http://mail.openjdk.java.net/pipermail/core-libs-dev/2012-May/010257.html - // Work around to check for either. + // NOTE: The String class definition varies across JDK versions (1.6 vs. 1.7) and vendors + // (Sun vs IBM). Use a DummyString class to make tests deterministic. test("strings") { - SizeEstimator.estimate(DummyString("")) should (equal (48) or equal (40)) - SizeEstimator.estimate(DummyString("a")) should (equal (56) or equal (48)) - SizeEstimator.estimate(DummyString("ab")) should (equal (56) or equal (48)) - SizeEstimator.estimate(DummyString("abcdefgh")) should (equal(64) or equal(56)) + expect(40)(SizeEstimator.estimate(DummyString(""))) + expect(48)(SizeEstimator.estimate(DummyString("a"))) + expect(48)(SizeEstimator.estimate(DummyString("ab"))) + expect(56)(SizeEstimator.estimate(DummyString("abcdefgh"))) } test("primitive arrays") { @@ -122,10 +119,8 @@ class SizeEstimatorSuite resetOrClear("os.arch", arch) } - // NOTE: The String class definition changed in JDK 7 to exclude the int fields count and length. - // This means that the size of strings will be lesser by 8 bytes in JDK 7 compared to JDK 6. - // http://mail.openjdk.java.net/pipermail/core-libs-dev/2012-May/010257.html - // Work around to check for either. + // NOTE: The String class definition varies across JDK versions (1.6 vs. 1.7) and vendors + // (Sun vs IBM). Use a DummyString class to make tests deterministic. test("64-bit arch with no compressed oops") { val arch = System.setProperty("os.arch", "amd64") val oops = System.setProperty("spark.test.useCompressedOops", "false") @@ -133,10 +128,10 @@ class SizeEstimatorSuite val initialize = PrivateMethod[Unit]('initialize) SizeEstimator invokePrivate initialize() - SizeEstimator.estimate(DummyString("")) should (equal (64) or equal (56)) - SizeEstimator.estimate(DummyString("a")) should (equal (72) or equal (64)) - SizeEstimator.estimate(DummyString("ab")) should (equal (72) or equal (64)) - SizeEstimator.estimate(DummyString("abcdefgh")) should (equal (80) or equal (72)) + expect(56)(SizeEstimator.estimate(DummyString(""))) + expect(64)(SizeEstimator.estimate(DummyString("a"))) + expect(64)(SizeEstimator.estimate(DummyString("ab"))) + expect(72)(SizeEstimator.estimate(DummyString("abcdefgh"))) resetOrClear("os.arch", arch) resetOrClear("spark.test.useCompressedOops", oops) From 4bbe07e5ece81fa874d2412bcc165179313a7619 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Mon, 7 Jan 2013 17:46:22 -0800 Subject: [PATCH 57/85] Activate hadoop1 profile by default for maven builds --- bagel/pom.xml | 3 +++ core/pom.xml | 5 ++++- examples/pom.xml | 3 +++ pom.xml | 3 +++ repl-bin/pom.xml | 3 +++ repl/pom.xml | 3 +++ 6 files changed, 19 insertions(+), 1 deletion(-) diff --git a/bagel/pom.xml b/bagel/pom.xml index a8256a6e8b..4ca643bbb7 100644 --- a/bagel/pom.xml +++ b/bagel/pom.xml @@ -45,6 +45,9 @@ hadoop1 + + true + org.spark-project diff --git a/core/pom.xml b/core/pom.xml index ae52c20657..cd789a7db0 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -159,6 +159,9 @@ hadoop1 + + true + org.apache.hadoop @@ -267,4 +270,4 @@ - \ No newline at end of file + diff --git a/examples/pom.xml b/examples/pom.xml index 782c026d73..9e638c8284 100644 --- a/examples/pom.xml +++ b/examples/pom.xml @@ -45,6 +45,9 @@ hadoop1 + + true + org.spark-project diff --git a/pom.xml b/pom.xml index fe5b1d0ee4..0e2d93c170 100644 --- a/pom.xml +++ b/pom.xml @@ -481,6 +481,9 @@ hadoop1 + + true + 1 diff --git a/repl-bin/pom.xml b/repl-bin/pom.xml index 0667b71cc7..aa9895eda2 100644 --- a/repl-bin/pom.xml +++ b/repl-bin/pom.xml @@ -70,6 +70,9 @@ hadoop1 + + true + hadoop1 diff --git a/repl/pom.xml b/repl/pom.xml index 114e3e9932..ba7a051310 100644 --- a/repl/pom.xml +++ b/repl/pom.xml @@ -72,6 +72,9 @@ hadoop1 + + true + hadoop1 From c41042c816c2d6299aa7d93529b7c39db5d5c03a Mon Sep 17 00:00:00 2001 From: Mikhail Bautin Date: Wed, 26 Dec 2012 15:52:51 -0800 Subject: [PATCH 58/85] Log preferred hosts --- .../main/scala/spark/scheduler/cluster/TaskSetManager.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala index cf4aae03a7..dda7a6c64a 100644 --- a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala +++ b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala @@ -201,7 +201,9 @@ private[spark] class TaskSetManager( val taskId = sched.newTaskId() // Figure out whether this should count as a preferred launch val preferred = isPreferredLocation(task, host) - val prefStr = if (preferred) "preferred" else "non-preferred" + val prefStr = if (preferred) "preferred" else + "non-preferred, not one of " + + task.preferredLocations.mkString(", ") logInfo("Starting task %s:%d as TID %s on slave %s: %s (%s)".format( taskSet.id, index, taskId, slaveId, host, prefStr)) // Do various bookkeeping From 4725b0f6439337c7a0f5f6fc7034c6f6b9488ae9 Mon Sep 17 00:00:00 2001 From: Mikhail Bautin Date: Mon, 7 Jan 2013 20:07:08 -0800 Subject: [PATCH 59/85] Fixing if/else coding style for preferred hosts logging --- .../main/scala/spark/scheduler/cluster/TaskSetManager.scala | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala index dda7a6c64a..a842afcdeb 100644 --- a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala +++ b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala @@ -201,9 +201,8 @@ private[spark] class TaskSetManager( val taskId = sched.newTaskId() // Figure out whether this should count as a preferred launch val preferred = isPreferredLocation(task, host) - val prefStr = if (preferred) "preferred" else - "non-preferred, not one of " + - task.preferredLocations.mkString(", ") + val prefStr = if (preferred) "preferred" + else "non-preferred, not one of " + task.preferredLocations.mkString(", ") logInfo("Starting task %s:%d as TID %s on slave %s: %s (%s)".format( taskSet.id, index, taskId, slaveId, host, prefStr)) // Do various bookkeeping From f7adb382ace7f54c5093bf90574b3f9dd0d35534 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Tue, 8 Jan 2013 03:19:43 -0800 Subject: [PATCH 60/85] Activate hadoop1 if property hadoop is missing. hadoop2 can be activated now by using -Dhadoop -Phadoop2. --- bagel/pom.xml | 4 +++- core/pom.xml | 4 +++- examples/pom.xml | 4 +++- pom.xml | 4 +++- repl-bin/pom.xml | 4 +++- repl/pom.xml | 4 +++- 6 files changed, 18 insertions(+), 6 deletions(-) diff --git a/bagel/pom.xml b/bagel/pom.xml index 4ca643bbb7..85b2077026 100644 --- a/bagel/pom.xml +++ b/bagel/pom.xml @@ -46,7 +46,9 @@ hadoop1 - true + + !hadoop + diff --git a/core/pom.xml b/core/pom.xml index cd789a7db0..005d8fe498 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -160,7 +160,9 @@ hadoop1 - true + + !hadoop + diff --git a/examples/pom.xml b/examples/pom.xml index 9e638c8284..3f738a3f8c 100644 --- a/examples/pom.xml +++ b/examples/pom.xml @@ -46,7 +46,9 @@ hadoop1 - true + + !hadoop + diff --git a/pom.xml b/pom.xml index 0e2d93c170..ea5b9c9d05 100644 --- a/pom.xml +++ b/pom.xml @@ -482,7 +482,9 @@ hadoop1 - true + + !hadoop + 1 diff --git a/repl-bin/pom.xml b/repl-bin/pom.xml index aa9895eda2..fecb01f3cd 100644 --- a/repl-bin/pom.xml +++ b/repl-bin/pom.xml @@ -71,7 +71,9 @@ hadoop1 - true + + !hadoop + hadoop1 diff --git a/repl/pom.xml b/repl/pom.xml index ba7a051310..04b2c35beb 100644 --- a/repl/pom.xml +++ b/repl/pom.xml @@ -73,7 +73,9 @@ hadoop1 - true + + !hadoop + hadoop1 From e4cb72da8a5428c6b9097e92ddbdf4ceee087b85 Mon Sep 17 00:00:00 2001 From: shane-huang Date: Tue, 8 Jan 2013 22:40:58 +0800 Subject: [PATCH 61/85] Fix an issue in ConnectionManager where sendingMessage may create too many unnecessary SendingConnections. --- .../main/scala/spark/network/Connection.scala | 7 +++++-- .../spark/network/ConnectionManager.scala | 17 +++++++++-------- .../spark/network/ConnectionManagerTest.scala | 18 +++++++++--------- 3 files changed, 23 insertions(+), 19 deletions(-) diff --git a/core/src/main/scala/spark/network/Connection.scala b/core/src/main/scala/spark/network/Connection.scala index 80262ab7b4..95096fd0ba 100644 --- a/core/src/main/scala/spark/network/Connection.scala +++ b/core/src/main/scala/spark/network/Connection.scala @@ -135,8 +135,11 @@ extends Connection(SocketChannel.open, selector_) { val chunk = message.getChunkForSending(defaultChunkSize) if (chunk.isDefined) { messages += message // this is probably incorrect, it wont work as fifo - if (!message.started) logDebug("Starting to send [" + message + "]") - message.started = true + if (!message.started) { + logDebug("Starting to send [" + message + "]") + message.started = true + message.startTime = System.currentTimeMillis + } return chunk } else { /*logInfo("Finished sending [" + message + "] to [" + remoteConnectionManagerId + "]")*/ diff --git a/core/src/main/scala/spark/network/ConnectionManager.scala b/core/src/main/scala/spark/network/ConnectionManager.scala index 642fa4b525..e7bd2d3bbd 100644 --- a/core/src/main/scala/spark/network/ConnectionManager.scala +++ b/core/src/main/scala/spark/network/ConnectionManager.scala @@ -43,12 +43,12 @@ private[spark] class ConnectionManager(port: Int) extends Logging { } val selector = SelectorProvider.provider.openSelector() - val handleMessageExecutor = Executors.newFixedThreadPool(4) + val handleMessageExecutor = Executors.newFixedThreadPool(20) val serverChannel = ServerSocketChannel.open() val connectionsByKey = new HashMap[SelectionKey, Connection] with SynchronizedMap[SelectionKey, Connection] val connectionsById = new HashMap[ConnectionManagerId, SendingConnection] with SynchronizedMap[ConnectionManagerId, SendingConnection] val messageStatuses = new HashMap[Int, MessageStatus] - val connectionRequests = new SynchronizedQueue[SendingConnection] + val connectionRequests = new HashMap[ConnectionManagerId, SendingConnection] with SynchronizedMap[ConnectionManagerId, SendingConnection] val keyInterestChangeRequests = new SynchronizedQueue[(SelectionKey, Int)] val sendMessageRequests = new Queue[(Message, SendingConnection)] @@ -78,11 +78,12 @@ private[spark] class ConnectionManager(port: Int) extends Logging { def run() { try { - while(!selectorThread.isInterrupted) { - while(!connectionRequests.isEmpty) { - val sendingConnection = connectionRequests.dequeue + while(!selectorThread.isInterrupted) { + for( (connectionManagerId, sendingConnection) <- connectionRequests) { + //val sendingConnection = connectionRequests.dequeue sendingConnection.connect() addConnection(sendingConnection) + connectionRequests -= connectionManagerId } sendMessageRequests.synchronized { while(!sendMessageRequests.isEmpty) { @@ -300,8 +301,7 @@ private[spark] class ConnectionManager(port: Int) extends Logging { private def sendMessage(connectionManagerId: ConnectionManagerId, message: Message) { def startNewConnection(): SendingConnection = { val inetSocketAddress = new InetSocketAddress(connectionManagerId.host, connectionManagerId.port) - val newConnection = new SendingConnection(inetSocketAddress, selector) - connectionRequests += newConnection + val newConnection = connectionRequests.getOrElseUpdate(connectionManagerId, new SendingConnection(inetSocketAddress, selector)) newConnection } val lookupKey = ConnectionManagerId.fromSocketAddress(connectionManagerId.toSocketAddress) @@ -465,7 +465,7 @@ private[spark] object ConnectionManager { val bufferMessage = Message.createBufferMessage(buffer.duplicate) manager.sendMessageReliably(manager.id, bufferMessage) }).foreach(f => { - val g = Await.result(f, 1 second) + val g = Await.result(f, 10 second) if (!g.isDefined) println("Failed") }) val finishTime = System.currentTimeMillis @@ -473,6 +473,7 @@ private[spark] object ConnectionManager { val mb = size * count / 1024.0 / 1024.0 val ms = finishTime - startTime val tput = mb * 1000.0 / ms + println("Sent " + mb + " MB in " + ms + " ms (" + tput + " MB/s)") println("--------------------------") println() } diff --git a/core/src/main/scala/spark/network/ConnectionManagerTest.scala b/core/src/main/scala/spark/network/ConnectionManagerTest.scala index 47ceaf3c07..0e79c518e0 100644 --- a/core/src/main/scala/spark/network/ConnectionManagerTest.scala +++ b/core/src/main/scala/spark/network/ConnectionManagerTest.scala @@ -13,8 +13,8 @@ import akka.util.duration._ private[spark] object ConnectionManagerTest extends Logging{ def main(args: Array[String]) { - if (args.length < 2) { - println("Usage: ConnectionManagerTest ") + if (args.length < 5) { + println("Usage: ConnectionManagerTest ") System.exit(1) } @@ -29,16 +29,16 @@ private[spark] object ConnectionManagerTest extends Logging{ /*println("Slaves")*/ /*slaves.foreach(println)*/ - - val slaveConnManagerIds = sc.parallelize(0 until slaves.length, slaves.length).map( + val tasknum = args(2).toInt + val slaveConnManagerIds = sc.parallelize(0 until tasknum, tasknum).map( i => SparkEnv.get.connectionManager.id).collect() println("\nSlave ConnectionManagerIds") slaveConnManagerIds.foreach(println) println - val count = 10 + val count = args(4).toInt (0 until count).foreach(i => { - val resultStrs = sc.parallelize(0 until slaves.length, slaves.length).map(i => { + val resultStrs = sc.parallelize(0 until tasknum, tasknum).map(i => { val connManager = SparkEnv.get.connectionManager val thisConnManagerId = connManager.id connManager.onReceiveMessage((msg: Message, id: ConnectionManagerId) => { @@ -46,7 +46,7 @@ private[spark] object ConnectionManagerTest extends Logging{ None }) - val size = 100 * 1024 * 1024 + val size = (args(3).toInt) * 1024 * 1024 val buffer = ByteBuffer.allocate(size).put(Array.tabulate[Byte](size)(x => x.toByte)) buffer.flip @@ -56,13 +56,13 @@ private[spark] object ConnectionManagerTest extends Logging{ logInfo("Sending [" + bufferMessage + "] to [" + slaveConnManagerId + "]") connManager.sendMessageReliably(slaveConnManagerId, bufferMessage) }) - val results = futures.map(f => Await.result(f, 1.second)) + val results = futures.map(f => Await.result(f, 999.second)) val finishTime = System.currentTimeMillis Thread.sleep(5000) val mb = size * results.size / 1024.0 / 1024.0 val ms = finishTime - startTime - val resultStr = "Sent " + mb + " MB in " + ms + " ms at " + (mb / ms * 1000.0) + " MB/s" + val resultStr = thisConnManagerId + " Sent " + mb + " MB in " + ms + " ms at " + (mb / ms * 1000.0) + " MB/s" logInfo(resultStr) resultStr }).collect() From 8ac0f35be42765fcd6f02dcf0f070f2ef2377a85 Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Tue, 8 Jan 2013 09:57:45 -0600 Subject: [PATCH 62/85] Add JavaRDDLike.keyBy. --- core/src/main/scala/spark/api/java/JavaRDDLike.scala | 8 ++++++++ core/src/test/scala/spark/JavaAPISuite.java | 12 ++++++++++++ 2 files changed, 20 insertions(+) diff --git a/core/src/main/scala/spark/api/java/JavaRDDLike.scala b/core/src/main/scala/spark/api/java/JavaRDDLike.scala index 81d3a94466..d15f6dd02f 100644 --- a/core/src/main/scala/spark/api/java/JavaRDDLike.scala +++ b/core/src/main/scala/spark/api/java/JavaRDDLike.scala @@ -298,4 +298,12 @@ trait JavaRDDLike[T, This <: JavaRDDLike[T, This]] extends Serializable { * Save this RDD as a SequenceFile of serialized objects. */ def saveAsObjectFile(path: String) = rdd.saveAsObjectFile(path) + + /** + * Creates tuples of the elements in this RDD by applying `f`. + */ + def keyBy[K](f: JFunction[T, K]): JavaPairRDD[K, T] = { + implicit val kcm: ClassManifest[K] = implicitly[ClassManifest[AnyRef]].asInstanceOf[ClassManifest[K]] + JavaPairRDD.fromRDD(rdd.keyBy(f)) + } } diff --git a/core/src/test/scala/spark/JavaAPISuite.java b/core/src/test/scala/spark/JavaAPISuite.java index 0817d1146c..c61913fc82 100644 --- a/core/src/test/scala/spark/JavaAPISuite.java +++ b/core/src/test/scala/spark/JavaAPISuite.java @@ -629,4 +629,16 @@ public class JavaAPISuite implements Serializable { floatAccum.setValue(5.0f); Assert.assertEquals((Float) 5.0f, floatAccum.value()); } + + @Test + public void keyBy() { + JavaRDD rdd = sc.parallelize(Arrays.asList(1, 2)); + List> s = rdd.keyBy(new Function() { + public String call(Integer t) throws Exception { + return t.toString(); + } + }).collect(); + Assert.assertEquals(new Tuple2("1", 1), s.get(0)); + Assert.assertEquals(new Tuple2("2", 2), s.get(1)); + } } From c3f1675f9c4a1be9eebf9512795abc968ac29ba2 Mon Sep 17 00:00:00 2001 From: Stephen Haberman Date: Tue, 8 Jan 2013 14:44:33 -0600 Subject: [PATCH 63/85] Retrieve jars to a flat directory so * can be used for the classpath. --- project/SparkBuild.scala | 1 + run | 12 +++--------- 2 files changed, 4 insertions(+), 9 deletions(-) diff --git a/project/SparkBuild.scala b/project/SparkBuild.scala index 7c7c33131a..518c4130f0 100644 --- a/project/SparkBuild.scala +++ b/project/SparkBuild.scala @@ -38,6 +38,7 @@ object SparkBuild extends Build { scalacOptions := Seq(/*"-deprecation",*/ "-unchecked", "-optimize"), // -deprecation is too noisy due to usage of old Hadoop API, enable it once that's no longer an issue unmanagedJars in Compile <<= baseDirectory map { base => (base / "lib" ** "*.jar").classpath }, retrieveManaged := true, + retrievePattern := "[type]s/[artifact](-[revision])(-[classifier]).[ext]", transitiveClassifiers in Scope.GlobalScope := Seq("sources"), testListeners <<= target.map(t => Seq(new eu.henkelmann.sbt.JUnitXmlTestsListener(t.getAbsolutePath))), diff --git a/run b/run index 1528f83534..6cfe9631af 100755 --- a/run +++ b/run @@ -75,16 +75,10 @@ CLASSPATH+=":$CORE_DIR/src/main/resources" CLASSPATH+=":$REPL_DIR/target/scala-$SCALA_VERSION/classes" CLASSPATH+=":$EXAMPLES_DIR/target/scala-$SCALA_VERSION/classes" if [ -e "$FWDIR/lib_managed" ]; then - for jar in `find "$FWDIR/lib_managed/jars" -name '*jar'`; do - CLASSPATH+=":$jar" - done - for jar in `find "$FWDIR/lib_managed/bundles" -name '*jar'`; do - CLASSPATH+=":$jar" - done + CLASSPATH+=":$FWDIR/lib_managed/jars/*" + CLASSPATH+=":$FWDIR/lib_managed/bundles/*" fi -for jar in `find "$REPL_DIR/lib" -name '*jar'`; do - CLASSPATH+=":$jar" -done +CLASSPATH+=":$REPL_DIR/lib/*" for jar in `find "$REPL_DIR/target" -name 'spark-repl-*-shaded-hadoop*.jar'`; do CLASSPATH+=":$jar" done From b57dd0f16024a82dfc223e69528b9908b931f068 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Tue, 8 Jan 2013 16:04:41 -0800 Subject: [PATCH 64/85] Add mapPartitionsWithSplit() to PySpark. --- .../scala/spark/api/python/PythonRDD.scala | 5 +++ docs/python-programming-guide.md | 1 - python/pyspark/rdd.py | 33 ++++++++++++------- python/pyspark/worker.py | 4 ++- 4 files changed, 30 insertions(+), 13 deletions(-) diff --git a/core/src/main/scala/spark/api/python/PythonRDD.scala b/core/src/main/scala/spark/api/python/PythonRDD.scala index 79d824d494..f431ef28d3 100644 --- a/core/src/main/scala/spark/api/python/PythonRDD.scala +++ b/core/src/main/scala/spark/api/python/PythonRDD.scala @@ -65,6 +65,9 @@ private[spark] class PythonRDD[T: ClassManifest]( SparkEnv.set(env) val out = new PrintWriter(proc.getOutputStream) val dOut = new DataOutputStream(proc.getOutputStream) + // Split index + dOut.writeInt(split.index) + // Broadcast variables dOut.writeInt(broadcastVars.length) for (broadcast <- broadcastVars) { dOut.writeLong(broadcast.id) @@ -72,10 +75,12 @@ private[spark] class PythonRDD[T: ClassManifest]( dOut.write(broadcast.value) dOut.flush() } + // Serialized user code for (elem <- command) { out.println(elem) } out.flush() + // Data values for (elem <- parent.iterator(split, context)) { PythonRDD.writeAsPickle(elem, dOut) } diff --git a/docs/python-programming-guide.md b/docs/python-programming-guide.md index d963551296..78ef310a00 100644 --- a/docs/python-programming-guide.md +++ b/docs/python-programming-guide.md @@ -19,7 +19,6 @@ There are a few key differences between the Python and Scala APIs: - Accumulators - Special functions on RDDs of doubles, such as `mean` and `stdev` - `lookup` - - `mapPartitionsWithSplit` - `persist` at storage levels other than `MEMORY_ONLY` - `sample` - `sort` diff --git a/python/pyspark/rdd.py b/python/pyspark/rdd.py index 4ba417b2a2..1d36da42b0 100644 --- a/python/pyspark/rdd.py +++ b/python/pyspark/rdd.py @@ -55,7 +55,7 @@ class RDD(object): """ Return a new RDD containing the distinct elements in this RDD. """ - def func(iterator): return imap(f, iterator) + def func(split, iterator): return imap(f, iterator) return PipelinedRDD(self, func, preservesPartitioning) def flatMap(self, f, preservesPartitioning=False): @@ -69,8 +69,8 @@ class RDD(object): >>> sorted(rdd.flatMap(lambda x: [(x, x), (x, x)]).collect()) [(2, 2), (2, 2), (3, 3), (3, 3), (4, 4), (4, 4)] """ - def func(iterator): return chain.from_iterable(imap(f, iterator)) - return self.mapPartitions(func, preservesPartitioning) + def func(s, iterator): return chain.from_iterable(imap(f, iterator)) + return self.mapPartitionsWithSplit(func, preservesPartitioning) def mapPartitions(self, f, preservesPartitioning=False): """ @@ -81,9 +81,20 @@ class RDD(object): >>> rdd.mapPartitions(f).collect() [3, 7] """ - return PipelinedRDD(self, f, preservesPartitioning) + def func(s, iterator): return f(iterator) + return self.mapPartitionsWithSplit(func) - # TODO: mapPartitionsWithSplit + def mapPartitionsWithSplit(self, f, preservesPartitioning=False): + """ + Return a new RDD by applying a function to each partition of this RDD, + while tracking the index of the original partition. + + >>> rdd = sc.parallelize([1, 2, 3, 4], 4) + >>> def f(splitIndex, iterator): yield splitIndex + >>> rdd.mapPartitionsWithSplit(f).sum() + 6 + """ + return PipelinedRDD(self, f, preservesPartitioning) def filter(self, f): """ @@ -362,7 +373,7 @@ class RDD(object): >>> ''.join(input(glob(tempFile.name + "/part-0000*"))) '0\\n1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n' """ - def func(iterator): + def func(split, iterator): return (str(x).encode("utf-8") for x in iterator) keyed = PipelinedRDD(self, func) keyed._bypass_serializer = True @@ -500,7 +511,7 @@ class RDD(object): # Transferring O(n) objects to Java is too expensive. Instead, we'll # form the hash buckets in Python, transferring O(numSplits) objects # to Java. Each object is a (splitNumber, [objects]) pair. - def add_shuffle_key(iterator): + def add_shuffle_key(split, iterator): buckets = defaultdict(list) for (k, v) in iterator: buckets[hashFunc(k) % numSplits].append((k, v)) @@ -653,8 +664,8 @@ class PipelinedRDD(RDD): def __init__(self, prev, func, preservesPartitioning=False): if isinstance(prev, PipelinedRDD) and not prev.is_cached: prev_func = prev.func - def pipeline_func(iterator): - return func(prev_func(iterator)) + def pipeline_func(split, iterator): + return func(split, prev_func(split, iterator)) self.func = pipeline_func self.preservesPartitioning = \ prev.preservesPartitioning and preservesPartitioning @@ -677,8 +688,8 @@ class PipelinedRDD(RDD): if not self._bypass_serializer and self.ctx.batchSize != 1: oldfunc = self.func batchSize = self.ctx.batchSize - def batched_func(iterator): - return batched(oldfunc(iterator), batchSize) + def batched_func(split, iterator): + return batched(oldfunc(split, iterator), batchSize) func = batched_func cmds = [func, self._bypass_serializer] pipe_command = ' '.join(b64enc(cloudpickle.dumps(f)) for f in cmds) diff --git a/python/pyspark/worker.py b/python/pyspark/worker.py index 9f6b507dbd..3d792bbaa2 100644 --- a/python/pyspark/worker.py +++ b/python/pyspark/worker.py @@ -21,6 +21,7 @@ def load_obj(): def main(): + split_index = read_int(sys.stdin) num_broadcast_variables = read_int(sys.stdin) for _ in range(num_broadcast_variables): bid = read_long(sys.stdin) @@ -32,7 +33,8 @@ def main(): dumps = lambda x: x else: dumps = dump_pickle - for obj in func(read_from_pickle_file(sys.stdin)): + iterator = read_from_pickle_file(sys.stdin) + for obj in func(split_index, iterator): write_with_length(dumps(obj), old_stdout) From 9cc764f52323baa3a218ce9e301d3cc98f1e8b20 Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Tue, 8 Jan 2013 22:29:57 -0800 Subject: [PATCH 65/85] Code style --- .../scala/spark/scheduler/cluster/TaskSetManager.scala | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala index a842afcdeb..a089b71644 100644 --- a/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala +++ b/core/src/main/scala/spark/scheduler/cluster/TaskSetManager.scala @@ -201,8 +201,11 @@ private[spark] class TaskSetManager( val taskId = sched.newTaskId() // Figure out whether this should count as a preferred launch val preferred = isPreferredLocation(task, host) - val prefStr = if (preferred) "preferred" - else "non-preferred, not one of " + task.preferredLocations.mkString(", ") + val prefStr = if (preferred) { + "preferred" + } else { + "non-preferred, not one of " + task.preferredLocations.mkString(", ") + } logInfo("Starting task %s:%d as TID %s on slave %s: %s (%s)".format( taskSet.id, index, taskId, slaveId, host, prefStr)) // Do various bookkeeping From 6e8c8f61c478ec5829677a38a624f17ac9609f74 Mon Sep 17 00:00:00 2001 From: Tyson Date: Wed, 9 Jan 2013 10:35:23 -0500 Subject: [PATCH 66/85] Added the spray implicit marshaller library Added the io.spray JSON library --- project/SparkBuild.scala | 2 ++ 1 file changed, 2 insertions(+) diff --git a/project/SparkBuild.scala b/project/SparkBuild.scala index 2f67bb9921..f2b79d9ed8 100644 --- a/project/SparkBuild.scala +++ b/project/SparkBuild.scala @@ -133,6 +133,8 @@ object SparkBuild extends Build { "colt" % "colt" % "1.2.0", "cc.spray" % "spray-can" % "1.0-M2.1", "cc.spray" % "spray-server" % "1.0-M2.1", + "cc.spray" %% "spray-json" % "1.1.1", + "io.spray" %% "spray-json" % "1.2.3", "org.apache.mesos" % "mesos" % "0.9.0-incubating" ) ++ (if (HADOOP_MAJOR_VERSION == "2") Some("org.apache.hadoop" % "hadoop-client" % HADOOP_VERSION) else None).toSeq, unmanagedSourceDirectories in Compile <+= baseDirectory{ _ / ("src/hadoop" + HADOOP_MAJOR_VERSION + "/scala") } From 269fe018c73a0d4e12a3c881dbd3bd807e504891 Mon Sep 17 00:00:00 2001 From: Tyson Date: Wed, 9 Jan 2013 10:35:59 -0500 Subject: [PATCH 67/85] JSON object definitions --- .../scala/spark/deploy/JsonProtocol.scala | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 core/src/main/scala/spark/deploy/JsonProtocol.scala diff --git a/core/src/main/scala/spark/deploy/JsonProtocol.scala b/core/src/main/scala/spark/deploy/JsonProtocol.scala new file mode 100644 index 0000000000..dc7da85f9c --- /dev/null +++ b/core/src/main/scala/spark/deploy/JsonProtocol.scala @@ -0,0 +1,59 @@ +package spark.deploy + +import master.{JobInfo, WorkerInfo} +import spray.json._ + +/** + * spray-json helper class containing implicit conversion to json for marshalling responses + */ +private[spark] object JsonProtocol extends DefaultJsonProtocol { + import cc.spray.json._ + + implicit object WorkerInfoJsonFormat extends RootJsonWriter[WorkerInfo] { + def write(obj: WorkerInfo) = JsObject( + "id" -> JsString(obj.id), + "host" -> JsString(obj.host), + "webuiaddress" -> JsString(obj.webUiAddress), + "cores" -> JsNumber(obj.cores), + "coresused" -> JsNumber(obj.coresUsed), + "memory" -> JsNumber(obj.memory), + "memoryused" -> JsNumber(obj.memoryUsed) + ) + } + + implicit object JobInfoJsonFormat extends RootJsonWriter[JobInfo] { + def write(obj: JobInfo) = JsObject( + "starttime" -> JsNumber(obj.startTime), + "id" -> JsString(obj.id), + "name" -> JsString(obj.desc.name), + "cores" -> JsNumber(obj.desc.cores), + "user" -> JsString(obj.desc.user), + "memoryperslave" -> JsNumber(obj.desc.memoryPerSlave), + "submitdate" -> JsString(obj.submitDate.toString)) + } + + implicit object MasterStateJsonFormat extends RootJsonWriter[MasterState] { + def write(obj: MasterState) = JsObject( + "url" -> JsString("spark://" + obj.uri), + "workers" -> JsArray(obj.workers.toList.map(_.toJson)), + "cores" -> JsNumber(obj.workers.map(_.cores).sum), + "coresused" -> JsNumber(obj.workers.map(_.coresUsed).sum), + "memory" -> JsNumber(obj.workers.map(_.memory).sum), + "memoryused" -> JsNumber(obj.workers.map(_.memoryUsed).sum), + "activejobs" -> JsArray(obj.activeJobs.toList.map(_.toJson)), + "completedjobs" -> JsArray(obj.completedJobs.toList.map(_.toJson)) + ) + } + + implicit object WorkerStateJsonFormat extends RootJsonWriter[WorkerState] { + def write(obj: WorkerState) = JsObject( + "id" -> JsString(obj.workerId), + "masterurl" -> JsString(obj.masterUrl), + "masterwebuiurl" -> JsString(obj.masterWebUiUrl), + "cores" -> JsNumber(obj.cores), + "coresused" -> JsNumber(obj.coresUsed), + "memory" -> JsNumber(obj.memory), + "memoryused" -> JsNumber(obj.memoryUsed) + ) + } +} From 0da2ff102e1e8ac50059252a153a1b9b3e74b6b8 Mon Sep 17 00:00:00 2001 From: Tyson Date: Wed, 9 Jan 2013 10:36:56 -0500 Subject: [PATCH 68/85] Added url query parameter json and handler --- .../spark/deploy/master/MasterWebUI.scala | 19 +++++++++++++----- .../spark/deploy/worker/WorkerWebUI.scala | 20 ++++++++++++++----- 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala index 3cdd3721f5..dfec1d1dc5 100644 --- a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala +++ b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala @@ -9,6 +9,9 @@ import cc.spray.Directives import cc.spray.directives._ import cc.spray.typeconversion.TwirlSupport._ import spark.deploy._ +import cc.spray.http.MediaTypes +import JsonProtocol._ +import cc.spray.typeconversion.SprayJsonSupport._ private[spark] class MasterWebUI(val actorSystem: ActorSystem, master: ActorRef) extends Directives { @@ -19,13 +22,19 @@ class MasterWebUI(val actorSystem: ActorSystem, master: ActorRef) extends Direct val handler = { get { - path("") { - completeWith { + (path("") & parameters('json ?)) { + case Some(js) => val future = master ? RequestMasterState - future.map { - masterState => spark.deploy.master.html.index.render(masterState.asInstanceOf[MasterState]) + respondWithMediaType(MediaTypes.`application/json`) { ctx => + ctx.complete(future.mapTo[MasterState]) + } + case None => + completeWith { + val future = master ? RequestMasterState + future.map { + masterState => spark.deploy.master.html.index.render(masterState.asInstanceOf[MasterState]) + } } - } } ~ path("job") { parameter("jobId") { jobId => diff --git a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala index d06f4884ee..a168f54ca0 100644 --- a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala +++ b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala @@ -7,7 +7,10 @@ import akka.util.Timeout import akka.util.duration._ import cc.spray.Directives import cc.spray.typeconversion.TwirlSupport._ -import spark.deploy.{WorkerState, RequestWorkerState} +import spark.deploy.{JsonProtocol, WorkerState, RequestWorkerState} +import cc.spray.http.MediaTypes +import JsonProtocol._ +import cc.spray.typeconversion.SprayJsonSupport._ private[spark] class WorkerWebUI(val actorSystem: ActorSystem, worker: ActorRef) extends Directives { @@ -18,13 +21,20 @@ class WorkerWebUI(val actorSystem: ActorSystem, worker: ActorRef) extends Direct val handler = { get { - path("") { - completeWith{ + (path("") & parameters('json ?)) { + case Some(js) => { val future = worker ? RequestWorkerState - future.map { workerState => - spark.deploy.worker.html.index(workerState.asInstanceOf[WorkerState]) + respondWithMediaType(MediaTypes.`application/json`) { ctx => + ctx.complete(future.mapTo[WorkerState]) } } + case None => + completeWith{ + val future = worker ? RequestWorkerState + future.map { workerState => + spark.deploy.worker.html.index(workerState.asInstanceOf[WorkerState]) + } + } } ~ path("log") { parameters("jobId", "executorId", "logType") { (jobId, executorId, logType) => From bf9d9946f97782c9212420123b4a042918d7df5e Mon Sep 17 00:00:00 2001 From: Tyson Date: Wed, 9 Jan 2013 11:29:22 -0500 Subject: [PATCH 69/85] Query parameter reformatted to be more extensible and routing more robust --- core/src/main/scala/spark/deploy/master/MasterWebUI.scala | 6 +++--- core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala index dfec1d1dc5..a96b55d6f3 100644 --- a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala +++ b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala @@ -22,13 +22,13 @@ class MasterWebUI(val actorSystem: ActorSystem, master: ActorRef) extends Direct val handler = { get { - (path("") & parameters('json ?)) { - case Some(js) => + (path("") & parameters('format ?)) { + case Some(js) if js.equalsIgnoreCase("json") => val future = master ? RequestMasterState respondWithMediaType(MediaTypes.`application/json`) { ctx => ctx.complete(future.mapTo[MasterState]) } - case None => + case _ => completeWith { val future = master ? RequestMasterState future.map { diff --git a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala index a168f54ca0..84b6c16bd6 100644 --- a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala +++ b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala @@ -21,14 +21,14 @@ class WorkerWebUI(val actorSystem: ActorSystem, worker: ActorRef) extends Direct val handler = { get { - (path("") & parameters('json ?)) { - case Some(js) => { + (path("") & parameters('format ?)) { + case Some(js) if js.equalsIgnoreCase("json") => { val future = worker ? RequestWorkerState respondWithMediaType(MediaTypes.`application/json`) { ctx => ctx.complete(future.mapTo[WorkerState]) } } - case None => + case _ => completeWith{ val future = worker ? RequestWorkerState future.map { workerState => From 549ee388a125ac7014ae3dadfb16c582e250c654 Mon Sep 17 00:00:00 2001 From: Tyson Date: Wed, 9 Jan 2013 15:12:23 -0500 Subject: [PATCH 70/85] Removed io.spray spray-json dependency as it is not needed. --- core/src/main/scala/spark/deploy/JsonProtocol.scala | 4 +--- project/SparkBuild.scala | 1 - 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/core/src/main/scala/spark/deploy/JsonProtocol.scala b/core/src/main/scala/spark/deploy/JsonProtocol.scala index dc7da85f9c..f14f804b3a 100644 --- a/core/src/main/scala/spark/deploy/JsonProtocol.scala +++ b/core/src/main/scala/spark/deploy/JsonProtocol.scala @@ -1,14 +1,12 @@ package spark.deploy import master.{JobInfo, WorkerInfo} -import spray.json._ +import cc.spray.json._ /** * spray-json helper class containing implicit conversion to json for marshalling responses */ private[spark] object JsonProtocol extends DefaultJsonProtocol { - import cc.spray.json._ - implicit object WorkerInfoJsonFormat extends RootJsonWriter[WorkerInfo] { def write(obj: WorkerInfo) = JsObject( "id" -> JsString(obj.id), diff --git a/project/SparkBuild.scala b/project/SparkBuild.scala index f2b79d9ed8..c63efbdd2a 100644 --- a/project/SparkBuild.scala +++ b/project/SparkBuild.scala @@ -134,7 +134,6 @@ object SparkBuild extends Build { "cc.spray" % "spray-can" % "1.0-M2.1", "cc.spray" % "spray-server" % "1.0-M2.1", "cc.spray" %% "spray-json" % "1.1.1", - "io.spray" %% "spray-json" % "1.2.3", "org.apache.mesos" % "mesos" % "0.9.0-incubating" ) ++ (if (HADOOP_MAJOR_VERSION == "2") Some("org.apache.hadoop" % "hadoop-client" % HADOOP_VERSION) else None).toSeq, unmanagedSourceDirectories in Compile <+= baseDirectory{ _ / ("src/hadoop" + HADOOP_MAJOR_VERSION + "/scala") } From 1a64432ba50904c3933d8a9539a619fc94b3b30b Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Wed, 9 Jan 2013 20:30:36 -0800 Subject: [PATCH 71/85] Indicate success/failure in PySpark test script. --- python/run-tests | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/python/run-tests b/python/run-tests index da9e24cb1f..fcdd1e27a7 100755 --- a/python/run-tests +++ b/python/run-tests @@ -3,7 +3,24 @@ # Figure out where the Scala framework is installed FWDIR="$(cd `dirname $0`; cd ../; pwd)" +FAILED=0 + $FWDIR/pyspark pyspark/rdd.py +FAILED=$(($?||$FAILED)) + $FWDIR/pyspark -m doctest pyspark/broadcast.py +FAILED=$(($?||$FAILED)) + +if [[ $FAILED != 0 ]]; then + echo -en "\033[31m" # Red + echo "Had test failures; see logs." + echo -en "\033[0m" # No color + exit -1 +else + echo -en "\033[32m" # Green + echo "Tests passed." + echo -en "\033[0m" # No color +fi # TODO: in the long-run, it would be nice to use a test runner like `nose`. +# The doctest fixtures are the current barrier to doing this. From d55f2b98822faa7d71f5fce2bfa980f8265e0610 Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Wed, 9 Jan 2013 21:21:23 -0800 Subject: [PATCH 72/85] Use take() instead of takeSample() in PySpark kmeans example. This is a temporary change until we port takeSample(). --- python/examples/kmeans.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/python/examples/kmeans.py b/python/examples/kmeans.py index ad2be21178..72cf9f88c6 100644 --- a/python/examples/kmeans.py +++ b/python/examples/kmeans.py @@ -33,7 +33,9 @@ if __name__ == "__main__": K = int(sys.argv[3]) convergeDist = float(sys.argv[4]) - kPoints = data.takeSample(False, K, 34) + # TODO: change this after we port takeSample() + #kPoints = data.takeSample(False, K, 34) + kPoints = data.take(K) tempDist = 1.0 while tempDist > convergeDist: From 9930a95d217045c4c22c2575080a03e4b0fd2426 Mon Sep 17 00:00:00 2001 From: shane-huang Date: Thu, 10 Jan 2013 20:09:34 +0800 Subject: [PATCH 73/85] Modified Patch according to comments --- .../main/scala/spark/network/Connection.scala | 8 ++++---- .../spark/network/ConnectionManager.scala | 9 ++++----- .../spark/network/ConnectionManagerTest.scala | 20 +++++++++++++------ 3 files changed, 22 insertions(+), 15 deletions(-) diff --git a/core/src/main/scala/spark/network/Connection.scala b/core/src/main/scala/spark/network/Connection.scala index 95096fd0ba..c193bf7c8d 100644 --- a/core/src/main/scala/spark/network/Connection.scala +++ b/core/src/main/scala/spark/network/Connection.scala @@ -136,10 +136,10 @@ extends Connection(SocketChannel.open, selector_) { if (chunk.isDefined) { messages += message // this is probably incorrect, it wont work as fifo if (!message.started) { - logDebug("Starting to send [" + message + "]") - message.started = true - message.startTime = System.currentTimeMillis - } + logDebug("Starting to send [" + message + "]") + message.started = true + message.startTime = System.currentTimeMillis + } return chunk } else { /*logInfo("Finished sending [" + message + "] to [" + remoteConnectionManagerId + "]")*/ diff --git a/core/src/main/scala/spark/network/ConnectionManager.scala b/core/src/main/scala/spark/network/ConnectionManager.scala index e7bd2d3bbd..36c01ad629 100644 --- a/core/src/main/scala/spark/network/ConnectionManager.scala +++ b/core/src/main/scala/spark/network/ConnectionManager.scala @@ -43,12 +43,12 @@ private[spark] class ConnectionManager(port: Int) extends Logging { } val selector = SelectorProvider.provider.openSelector() - val handleMessageExecutor = Executors.newFixedThreadPool(20) + val handleMessageExecutor = Executors.newFixedThreadPool(System.getProperty("spark.core.connection.handler.threads","20").toInt) val serverChannel = ServerSocketChannel.open() val connectionsByKey = new HashMap[SelectionKey, Connection] with SynchronizedMap[SelectionKey, Connection] val connectionsById = new HashMap[ConnectionManagerId, SendingConnection] with SynchronizedMap[ConnectionManagerId, SendingConnection] val messageStatuses = new HashMap[Int, MessageStatus] - val connectionRequests = new HashMap[ConnectionManagerId, SendingConnection] with SynchronizedMap[ConnectionManagerId, SendingConnection] + val connectionRequests = new HashMap[ConnectionManagerId, SendingConnection] with SynchronizedMap[ConnectionManagerId, SendingConnection] val keyInterestChangeRequests = new SynchronizedQueue[(SelectionKey, Int)] val sendMessageRequests = new Queue[(Message, SendingConnection)] @@ -78,9 +78,8 @@ private[spark] class ConnectionManager(port: Int) extends Logging { def run() { try { - while(!selectorThread.isInterrupted) { + while(!selectorThread.isInterrupted) { for( (connectionManagerId, sendingConnection) <- connectionRequests) { - //val sendingConnection = connectionRequests.dequeue sendingConnection.connect() addConnection(sendingConnection) connectionRequests -= connectionManagerId @@ -465,7 +464,7 @@ private[spark] object ConnectionManager { val bufferMessage = Message.createBufferMessage(buffer.duplicate) manager.sendMessageReliably(manager.id, bufferMessage) }).foreach(f => { - val g = Await.result(f, 10 second) + val g = Await.result(f, 1 second) if (!g.isDefined) println("Failed") }) val finishTime = System.currentTimeMillis diff --git a/core/src/main/scala/spark/network/ConnectionManagerTest.scala b/core/src/main/scala/spark/network/ConnectionManagerTest.scala index 0e79c518e0..533e4610f3 100644 --- a/core/src/main/scala/spark/network/ConnectionManagerTest.scala +++ b/core/src/main/scala/spark/network/ConnectionManagerTest.scala @@ -13,8 +13,14 @@ import akka.util.duration._ private[spark] object ConnectionManagerTest extends Logging{ def main(args: Array[String]) { - if (args.length < 5) { - println("Usage: ConnectionManagerTest ") + // - the master URL + // - a list slaves to run connectionTest on + //[num of tasks] - the number of parallel tasks to be initiated default is number of slave hosts + //[size of msg in MB (integer)] - the size of messages to be sent in each task, default is 10 + //[count] - how many times to run, default is 3 + //[await time in seconds] : await time (in seconds), default is 600 + if (args.length < 2) { + println("Usage: ConnectionManagerTest [num of tasks] [size of msg in MB (integer)] [count] [await time in seconds)] ") System.exit(1) } @@ -29,14 +35,17 @@ private[spark] object ConnectionManagerTest extends Logging{ /*println("Slaves")*/ /*slaves.foreach(println)*/ - val tasknum = args(2).toInt + val tasknum = if (args.length > 2) args(2).toInt else slaves.length + val size = ( if (args.length > 3) (args(3).toInt) else 10 ) * 1024 * 1024 + val count = if (args.length > 4) args(4).toInt else 3 + val awaitTime = (if (args.length > 5) args(5).toInt else 600 ).second + println("Running "+count+" rounds of test: " + "parallel tasks = " + tasknum + ", msg size = " + size/1024/1024 + " MB, awaitTime = " + awaitTime) val slaveConnManagerIds = sc.parallelize(0 until tasknum, tasknum).map( i => SparkEnv.get.connectionManager.id).collect() println("\nSlave ConnectionManagerIds") slaveConnManagerIds.foreach(println) println - val count = args(4).toInt (0 until count).foreach(i => { val resultStrs = sc.parallelize(0 until tasknum, tasknum).map(i => { val connManager = SparkEnv.get.connectionManager @@ -46,7 +55,6 @@ private[spark] object ConnectionManagerTest extends Logging{ None }) - val size = (args(3).toInt) * 1024 * 1024 val buffer = ByteBuffer.allocate(size).put(Array.tabulate[Byte](size)(x => x.toByte)) buffer.flip @@ -56,7 +64,7 @@ private[spark] object ConnectionManagerTest extends Logging{ logInfo("Sending [" + bufferMessage + "] to [" + slaveConnManagerId + "]") connManager.sendMessageReliably(slaveConnManagerId, bufferMessage) }) - val results = futures.map(f => Await.result(f, 999.second)) + val results = futures.map(f => Await.result(f, awaitTime)) val finishTime = System.currentTimeMillis Thread.sleep(5000) From 49c74ba2af2ab6fe5eda16dbcd35b30b46072a3a Mon Sep 17 00:00:00 2001 From: Josh Rosen Date: Thu, 10 Jan 2013 07:45:12 -0800 Subject: [PATCH 74/85] Change PYSPARK_PYTHON_EXEC to PYSPARK_PYTHON. --- python/pyspark/context.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/pyspark/context.py b/python/pyspark/context.py index 4439356c1f..e486f206b0 100644 --- a/python/pyspark/context.py +++ b/python/pyspark/context.py @@ -52,7 +52,7 @@ class SparkContext(object): self._jsc = self.jvm.JavaSparkContext(master, jobName, sparkHome, empty_string_array) - self.pythonExec = os.environ.get("PYSPARK_PYTHON_EXEC", 'python') + self.pythonExec = os.environ.get("PYSPARK_PYTHON", 'python') # Broadcast's __reduce__ method stores Broadcast instances here. # This allows other code to determine which Broadcast instances have # been pickled, so it can determine which Java broadcast objects to From bd336f5f406386c929f2d1f9aecd7d5190a1a087 Mon Sep 17 00:00:00 2001 From: Reynold Xin Date: Thu, 10 Jan 2013 17:13:04 -0800 Subject: [PATCH 75/85] Changed CoGroupRDD's hash map from Scala to Java. --- core/src/main/scala/spark/rdd/CoGroupedRDD.scala | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/core/src/main/scala/spark/rdd/CoGroupedRDD.scala b/core/src/main/scala/spark/rdd/CoGroupedRDD.scala index de0d9fad88..2e051c81c8 100644 --- a/core/src/main/scala/spark/rdd/CoGroupedRDD.scala +++ b/core/src/main/scala/spark/rdd/CoGroupedRDD.scala @@ -1,7 +1,8 @@ package spark.rdd +import java.util.{HashMap => JHashMap} import scala.collection.mutable.ArrayBuffer -import scala.collection.mutable.HashMap +import scala.collection.JavaConversions._ import spark.{Aggregator, Logging, Partitioner, RDD, SparkEnv, Split, TaskContext} import spark.{Dependency, OneToOneDependency, ShuffleDependency} @@ -71,7 +72,7 @@ class CoGroupedRDD[K](@transient rdds: Seq[RDD[(_, _)]], part: Partitioner) override def compute(s: Split, context: TaskContext): Iterator[(K, Seq[Seq[_]])] = { val split = s.asInstanceOf[CoGroupSplit] val numRdds = split.deps.size - val map = new HashMap[K, Seq[ArrayBuffer[Any]]] + val map = new JHashMap[K, Seq[ArrayBuffer[Any]]] def getSeq(k: K): Seq[ArrayBuffer[Any]] = { map.getOrElseUpdate(k, Array.fill(numRdds)(new ArrayBuffer[Any])) } From 2e914d99835487e867cac6add8be1dbd80dc693f Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Thu, 10 Jan 2013 19:13:08 -0800 Subject: [PATCH 76/85] Formatting --- core/src/main/scala/spark/deploy/master/MasterWebUI.scala | 5 +++-- core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala index a96b55d6f3..580014ef3f 100644 --- a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala +++ b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala @@ -8,11 +8,12 @@ import akka.util.duration._ import cc.spray.Directives import cc.spray.directives._ import cc.spray.typeconversion.TwirlSupport._ -import spark.deploy._ import cc.spray.http.MediaTypes -import JsonProtocol._ import cc.spray.typeconversion.SprayJsonSupport._ +import spark.deploy._ +import spark.deploy.JsonProtocol._ + private[spark] class MasterWebUI(val actorSystem: ActorSystem, master: ActorRef) extends Directives { val RESOURCE_DIR = "spark/deploy/master/webui" diff --git a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala index 84b6c16bd6..f9489d99fc 100644 --- a/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala +++ b/core/src/main/scala/spark/deploy/worker/WorkerWebUI.scala @@ -7,11 +7,12 @@ import akka.util.Timeout import akka.util.duration._ import cc.spray.Directives import cc.spray.typeconversion.TwirlSupport._ -import spark.deploy.{JsonProtocol, WorkerState, RequestWorkerState} import cc.spray.http.MediaTypes -import JsonProtocol._ import cc.spray.typeconversion.SprayJsonSupport._ +import spark.deploy.{WorkerState, RequestWorkerState} +import spark.deploy.JsonProtocol._ + private[spark] class WorkerWebUI(val actorSystem: ActorSystem, worker: ActorRef) extends Directives { val RESOURCE_DIR = "spark/deploy/worker/webui" From 92625223066a5c28553d7710c6b14af56f64b560 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Thu, 10 Jan 2013 22:07:34 -0800 Subject: [PATCH 77/85] Activate hadoop2 profile in pom.xml with -Dhadoop=2 --- bagel/pom.xml | 6 ++++++ core/pom.xml | 6 ++++++ examples/pom.xml | 6 ++++++ pom.xml | 6 ++++++ repl-bin/pom.xml | 6 ++++++ repl/pom.xml | 6 ++++++ 6 files changed, 36 insertions(+) diff --git a/bagel/pom.xml b/bagel/pom.xml index 85b2077026..c3461fb889 100644 --- a/bagel/pom.xml +++ b/bagel/pom.xml @@ -77,6 +77,12 @@ hadoop2 + + + hadoop + 2 + + org.spark-project diff --git a/core/pom.xml b/core/pom.xml index 005d8fe498..c8ff625774 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -216,6 +216,12 @@ hadoop2 + + + hadoop + 2 + + org.apache.hadoop diff --git a/examples/pom.xml b/examples/pom.xml index 3f738a3f8c..d0b1e97747 100644 --- a/examples/pom.xml +++ b/examples/pom.xml @@ -77,6 +77,12 @@ hadoop2 + + + hadoop + 2 + + org.spark-project diff --git a/pom.xml b/pom.xml index ea5b9c9d05..ae87813d4e 100644 --- a/pom.xml +++ b/pom.xml @@ -502,6 +502,12 @@ hadoop2 + + + hadoop + 2 + + 2 diff --git a/repl-bin/pom.xml b/repl-bin/pom.xml index fecb01f3cd..54ae20659e 100644 --- a/repl-bin/pom.xml +++ b/repl-bin/pom.xml @@ -115,6 +115,12 @@ hadoop2 + + + hadoop + 2 + + hadoop2 diff --git a/repl/pom.xml b/repl/pom.xml index 04b2c35beb..3e979b93a6 100644 --- a/repl/pom.xml +++ b/repl/pom.xml @@ -121,6 +121,12 @@ hadoop2 + + + hadoop + 2 + + hadoop2 From 480c4139bbd2711e99f3a819c9ef164d8b3dcac0 Mon Sep 17 00:00:00 2001 From: Michael Heuer Date: Fri, 11 Jan 2013 11:24:48 -0600 Subject: [PATCH 78/85] add repositories section to simple job pom.xml --- docs/quick-start.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/quick-start.md b/docs/quick-start.md index 177cb14551..d46dc2da3f 100644 --- a/docs/quick-start.md +++ b/docs/quick-start.md @@ -200,6 +200,16 @@ To build the job, we also write a Maven `pom.xml` file that lists Spark as a dep Simple Project jar 1.0 + + + Spray.cc repository + http://repo.spray.cc + + + Typesafe repository + http://repo.typesafe.com/typesafe/releases + + org.spark-project From c063e8777ebaeb04056889064e9264edc019edbd Mon Sep 17 00:00:00 2001 From: Tyson Date: Fri, 11 Jan 2013 14:57:38 -0500 Subject: [PATCH 79/85] Added implicit json writers for JobDescription and ExecutorRunner --- .../scala/spark/deploy/JsonProtocol.scala | 23 ++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/core/src/main/scala/spark/deploy/JsonProtocol.scala b/core/src/main/scala/spark/deploy/JsonProtocol.scala index f14f804b3a..732fa08064 100644 --- a/core/src/main/scala/spark/deploy/JsonProtocol.scala +++ b/core/src/main/scala/spark/deploy/JsonProtocol.scala @@ -1,6 +1,7 @@ package spark.deploy import master.{JobInfo, WorkerInfo} +import worker.ExecutorRunner import cc.spray.json._ /** @@ -30,6 +31,24 @@ private[spark] object JsonProtocol extends DefaultJsonProtocol { "submitdate" -> JsString(obj.submitDate.toString)) } + implicit object JobDescriptionJsonFormat extends RootJsonWriter[JobDescription] { + def write(obj: JobDescription) = JsObject( + "name" -> JsString(obj.name), + "cores" -> JsNumber(obj.cores), + "memoryperslave" -> JsNumber(obj.memoryPerSlave), + "user" -> JsString(obj.user) + ) + } + + implicit object ExecutorRunnerJsonFormat extends RootJsonWriter[ExecutorRunner] { + def write(obj: ExecutorRunner) = JsObject( + "id" -> JsNumber(obj.execId), + "memory" -> JsNumber(obj.memory), + "jobid" -> JsString(obj.jobId), + "jobdesc" -> obj.jobDesc.toJson.asJsObject + ) + } + implicit object MasterStateJsonFormat extends RootJsonWriter[MasterState] { def write(obj: MasterState) = JsObject( "url" -> JsString("spark://" + obj.uri), @@ -51,7 +70,9 @@ private[spark] object JsonProtocol extends DefaultJsonProtocol { "cores" -> JsNumber(obj.cores), "coresused" -> JsNumber(obj.coresUsed), "memory" -> JsNumber(obj.memory), - "memoryused" -> JsNumber(obj.memoryUsed) + "memoryused" -> JsNumber(obj.memoryUsed), + "executors" -> JsArray(obj.executors.toList.map(_.toJson)), + "finishedexecutors" -> JsArray(obj.finishedExecutors.toList.map(_.toJson)) ) } } From 1731f1fed4f1369662b1a9fde850a3dcba738a59 Mon Sep 17 00:00:00 2001 From: Tyson Date: Fri, 11 Jan 2013 15:01:43 -0500 Subject: [PATCH 80/85] Added an optional format parameter for individual job queries and optimized the jobId query --- .../spark/deploy/master/MasterWebUI.scala | 38 +++++++++++++------ 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala index 580014ef3f..458ee2d665 100644 --- a/core/src/main/scala/spark/deploy/master/MasterWebUI.scala +++ b/core/src/main/scala/spark/deploy/master/MasterWebUI.scala @@ -38,20 +38,36 @@ class MasterWebUI(val actorSystem: ActorSystem, master: ActorRef) extends Direct } } ~ path("job") { - parameter("jobId") { jobId => - completeWith { + parameters("jobId", 'format ?) { + case (jobId, Some(js)) if (js.equalsIgnoreCase("json")) => val future = master ? RequestMasterState - future.map { state => - val masterState = state.asInstanceOf[MasterState] - - // A bit ugly an inefficient, but we won't have a number of jobs - // so large that it will make a significant difference. - (masterState.activeJobs ++ masterState.completedJobs).find(_.id == jobId) match { - case Some(job) => spark.deploy.master.html.job_details.render(job) - case _ => null + val jobInfo = for (masterState <- future.mapTo[MasterState]) yield { + masterState.activeJobs.find(_.id == jobId) match { + case Some(job) => job + case _ => masterState.completedJobs.find(_.id == jobId) match { + case Some(job) => job + case _ => null + } + } + } + respondWithMediaType(MediaTypes.`application/json`) { ctx => + ctx.complete(jobInfo.mapTo[JobInfo]) + } + case (jobId, _) => + completeWith { + val future = master ? RequestMasterState + future.map { state => + val masterState = state.asInstanceOf[MasterState] + + masterState.activeJobs.find(_.id == jobId) match { + case Some(job) => spark.deploy.master.html.job_details.render(job) + case _ => masterState.completedJobs.find(_.id == jobId) match { + case Some(job) => spark.deploy.master.html.job_details.render(job) + case _ => null + } + } } } - } } } ~ pathPrefix("static") { From bbc56d85ed4eb4c3a09b20d5457f704f4b8a70c4 Mon Sep 17 00:00:00 2001 From: Shivaram Venkataraman Date: Sat, 12 Jan 2013 15:24:13 -0800 Subject: [PATCH 81/85] Rename environment variable for hadoop profiles to hadoopVersion --- bagel/pom.xml | 4 ++-- core/pom.xml | 4 ++-- examples/pom.xml | 4 ++-- pom.xml | 5 +++-- repl-bin/pom.xml | 4 ++-- repl/pom.xml | 4 ++-- 6 files changed, 13 insertions(+), 12 deletions(-) diff --git a/bagel/pom.xml b/bagel/pom.xml index c3461fb889..5f58347204 100644 --- a/bagel/pom.xml +++ b/bagel/pom.xml @@ -47,7 +47,7 @@ hadoop1 - !hadoop + !hadoopVersion @@ -79,7 +79,7 @@ hadoop2 - hadoop + hadoopVersion 2 diff --git a/core/pom.xml b/core/pom.xml index c8ff625774..ad9fdcde2c 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -161,7 +161,7 @@ hadoop1 - !hadoop + !hadoopVersion @@ -218,7 +218,7 @@ hadoop2 - hadoop + hadoopVersion 2 diff --git a/examples/pom.xml b/examples/pom.xml index d0b1e97747..3355deb6b7 100644 --- a/examples/pom.xml +++ b/examples/pom.xml @@ -47,7 +47,7 @@ hadoop1 - !hadoop + !hadoopVersion @@ -79,7 +79,7 @@ hadoop2 - hadoop + hadoopVersion 2 diff --git a/pom.xml b/pom.xml index ae87813d4e..8f1af673a3 100644 --- a/pom.xml +++ b/pom.xml @@ -483,9 +483,10 @@ hadoop1 - !hadoop + !hadoopVersion + 1 @@ -504,7 +505,7 @@ hadoop2 - hadoop + hadoopVersion 2 diff --git a/repl-bin/pom.xml b/repl-bin/pom.xml index 54ae20659e..da91c0f3ab 100644 --- a/repl-bin/pom.xml +++ b/repl-bin/pom.xml @@ -72,7 +72,7 @@ hadoop1 - !hadoop + !hadoopVersion @@ -117,7 +117,7 @@ hadoop2 - hadoop + hadoopVersion 2 diff --git a/repl/pom.xml b/repl/pom.xml index 3e979b93a6..38e883c7f8 100644 --- a/repl/pom.xml +++ b/repl/pom.xml @@ -74,7 +74,7 @@ hadoop1 - !hadoop + !hadoopVersion @@ -123,7 +123,7 @@ hadoop2 - hadoop + hadoopVersion 2 From ba06e9c97cc3f8723ffdc3895182c529d3bb2fb3 Mon Sep 17 00:00:00 2001 From: Eric Zhang Date: Sun, 13 Jan 2013 15:33:11 +0800 Subject: [PATCH 82/85] Update examples/src/main/scala/spark/examples/LocalLR.scala MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fix spelling mistake --- examples/src/main/scala/spark/examples/LocalLR.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/src/main/scala/spark/examples/LocalLR.scala b/examples/src/main/scala/spark/examples/LocalLR.scala index f2ac2b3e06..9553162004 100644 --- a/examples/src/main/scala/spark/examples/LocalLR.scala +++ b/examples/src/main/scala/spark/examples/LocalLR.scala @@ -5,7 +5,7 @@ import spark.util.Vector object LocalLR { val N = 10000 // Number of data points - val D = 10 // Numer of dimensions + val D = 10 // Number of dimensions val R = 0.7 // Scaling factor val ITERATIONS = 5 val rand = new Random(42) From 88d8f11365db84d46ff456495c07f664c91d1896 Mon Sep 17 00:00:00 2001 From: Mikhail Bautin Date: Sun, 13 Jan 2013 00:45:52 -0800 Subject: [PATCH 83/85] Add missing dependency spray-json to Maven build --- core/pom.xml | 4 ++++ pom.xml | 6 ++++++ 2 files changed, 10 insertions(+) diff --git a/core/pom.xml b/core/pom.xml index ad9fdcde2c..862d3ec37a 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -71,6 +71,10 @@ cc.spray spray-server + + cc.spray + spray-json_${scala.version} + org.tomdz.twirl twirl-api diff --git a/pom.xml b/pom.xml index 8f1af673a3..751189a9d8 100644 --- a/pom.xml +++ b/pom.xml @@ -54,6 +54,7 @@ 0.9.0-incubating 2.0.3 1.0-M2.1 + 1.1.1 1.6.1 4.1.2 @@ -222,6 +223,11 @@ spray-server ${spray.version} + + cc.spray + spray-json_${scala.version} + ${spray.json.version} + org.tomdz.twirl twirl-api From be7166146bf5692369272b85622d5316eccfd8e6 Mon Sep 17 00:00:00 2001 From: Reynold Xin Date: Sun, 13 Jan 2013 15:27:28 -0800 Subject: [PATCH 84/85] Removed the use of getOrElse to avoid Scala wrapper for every call. --- core/src/main/scala/spark/rdd/CoGroupedRDD.scala | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/core/src/main/scala/spark/rdd/CoGroupedRDD.scala b/core/src/main/scala/spark/rdd/CoGroupedRDD.scala index 2e051c81c8..ce5f171911 100644 --- a/core/src/main/scala/spark/rdd/CoGroupedRDD.scala +++ b/core/src/main/scala/spark/rdd/CoGroupedRDD.scala @@ -1,8 +1,8 @@ package spark.rdd import java.util.{HashMap => JHashMap} +import scala.collection.JavaConversions import scala.collection.mutable.ArrayBuffer -import scala.collection.JavaConversions._ import spark.{Aggregator, Logging, Partitioner, RDD, SparkEnv, Split, TaskContext} import spark.{Dependency, OneToOneDependency, ShuffleDependency} @@ -74,7 +74,14 @@ class CoGroupedRDD[K](@transient rdds: Seq[RDD[(_, _)]], part: Partitioner) val numRdds = split.deps.size val map = new JHashMap[K, Seq[ArrayBuffer[Any]]] def getSeq(k: K): Seq[ArrayBuffer[Any]] = { - map.getOrElseUpdate(k, Array.fill(numRdds)(new ArrayBuffer[Any])) + val seq = map.get(k) + if (seq != null) { + seq + } else { + val seq = Array.fill(numRdds)(new ArrayBuffer[Any]) + map.put(k, seq) + seq + } } for ((dep, depNum) <- split.deps.zipWithIndex) dep match { case NarrowCoGroupSplitDep(rdd, itsSplit) => { @@ -94,6 +101,6 @@ class CoGroupedRDD[K](@transient rdds: Seq[RDD[(_, _)]], part: Partitioner) fetcher.fetch[K, Seq[Any]](shuffleId, split.index).foreach(mergePair) } } - map.iterator + JavaConversions.mapAsScalaMap(map).iterator } } From 72408e8dfacc24652f376d1ee4dd6f04edb54804 Mon Sep 17 00:00:00 2001 From: Matei Zaharia Date: Sun, 13 Jan 2013 19:34:07 -0800 Subject: [PATCH 85/85] Make filter preserve partitioner info, since it can --- core/src/main/scala/spark/rdd/FilteredRDD.scala | 3 ++- core/src/test/scala/spark/PartitioningSuite.scala | 5 +++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/core/src/main/scala/spark/rdd/FilteredRDD.scala b/core/src/main/scala/spark/rdd/FilteredRDD.scala index b148da28de..d46549b8b6 100644 --- a/core/src/main/scala/spark/rdd/FilteredRDD.scala +++ b/core/src/main/scala/spark/rdd/FilteredRDD.scala @@ -7,5 +7,6 @@ private[spark] class FilteredRDD[T: ClassManifest](prev: RDD[T], f: T => Boolean) extends RDD[T](prev.context) { override def splits = prev.splits override val dependencies = List(new OneToOneDependency(prev)) + override val partitioner = prev.partitioner // Since filter cannot change a partition's keys override def compute(split: Split, context: TaskContext) = prev.iterator(split, context).filter(f) -} \ No newline at end of file +} diff --git a/core/src/test/scala/spark/PartitioningSuite.scala b/core/src/test/scala/spark/PartitioningSuite.scala index f09b602a7b..eb3c8f238f 100644 --- a/core/src/test/scala/spark/PartitioningSuite.scala +++ b/core/src/test/scala/spark/PartitioningSuite.scala @@ -106,6 +106,11 @@ class PartitioningSuite extends FunSuite with BeforeAndAfter { assert(grouped2.leftOuterJoin(reduced2).partitioner === grouped2.partitioner) assert(grouped2.rightOuterJoin(reduced2).partitioner === grouped2.partitioner) assert(grouped2.cogroup(reduced2).partitioner === grouped2.partitioner) + + assert(grouped2.map(_ => 1).partitioner === None) + assert(grouped2.mapValues(_ => 1).partitioner === grouped2.partitioner) + assert(grouped2.flatMapValues(_ => Seq(1)).partitioner === grouped2.partitioner) + assert(grouped2.filter(_._1 > 4).partitioner === grouped2.partitioner) } test("partitioning Java arrays should fail") {