Broadcast variables in Apache Spark - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of broadcast variable usage in Spark

What is the output of this Spark code snippet using a broadcast variable?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.master('local').appName('BroadcastTest').getOrCreate()
sc = spark.sparkContext

broadcastVar = sc.broadcast([1, 2, 3])
rdd = sc.parallelize([0, 1, 2, 3])
result = rdd.map(lambda x: broadcastVar.value[x] if x < len(broadcastVar.value) else -1).collect()
print(result)

A [0, 1, 2, 3]

B [1, 2, 3, -1]

C [1, 2, 3, 3]

D IndexError

💡 Hint

Remember that broadcast variables share data efficiently and you can access their value attribute.

The broadcast variable holds the list [1, 2, 3]. The RDD elements 0,1,2 are used as indices to access this list. For index 3, which is out of range, the code returns -1.

🧠 Conceptual

intermediate

Purpose of broadcast variables in Spark

What is the main purpose of using broadcast variables in Apache Spark?

A To efficiently share a read-only variable across all worker nodes without sending it with every task

B To cache RDDs in memory for faster access

C To shuffle data between partitions during a join operation

D To store intermediate results on disk to avoid recomputation

💡 Hint

Think about how to avoid sending the same data multiple times to workers.

Broadcast variables allow Spark to send a large read-only value to all worker nodes only once, reducing communication overhead.

🔧 Debug

advanced

Identify the error with broadcast variable usage

What error will this Spark code raise?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.master('local').appName('BroadcastError').getOrCreate()
sc = spark.sparkContext

broadcastVar = sc.broadcast({'a': 1, 'b': 2})
rdd = sc.parallelize(['a', 'b', 'c'])
result = rdd.map(lambda x: broadcastVar.value[x]).collect()
print(result)

A KeyError

B TypeError

C ValueError

D No error, output: [1, 2, None]

💡 Hint

Check what happens if a key is missing in a dictionary lookup.

The key 'c' is not in the broadcast dictionary, so accessing broadcastVar.value['c'] raises a KeyError.

❓ data_output

advanced

Result of modifying broadcast variable after creation

What is the output of this Spark code?

Apache Spark

from pyspark.sql import SparkSession
spark = SparkSession.builder.master('local').appName('BroadcastModify').getOrCreate()
sc = spark.sparkContext

broadcastVar = sc.broadcast([10, 20, 30])
broadcastVar.value.append(40)
rdd = sc.parallelize([0, 1, 2, 3])
result = rdd.map(lambda x: broadcastVar.value[x] if x < len(broadcastVar.value) else -1).collect()
print(result)

A [10, 20, 30, 40]

B [10, 20, 30]

C AttributeError

D [10, 20, 30, -1]

💡 Hint

Modifications to broadcast variables on the driver after creation do not propagate to workers.

The append(40) modifies the list only on the driver. Workers receive a copy of the list as it was at broadcast time ([10, 20, 30]), so len=3 on workers, and for x=3, -1 is returned.

🚀 Application

expert

Best use case for broadcast variables in a join operation

You have a large dataset A and a small dataset B. You want to join them in Spark efficiently. Which approach best uses broadcast variables?

A Use a standard shuffle join without broadcasting

B Broadcast the large dataset A and map over B to join using the broadcasted data

C Broadcast the small dataset B and map over A to join using the broadcasted data

D Collect both datasets to the driver and join locally

💡 Hint

Broadcasting the smaller dataset reduces shuffle and speeds up join.

Broadcasting the small dataset B allows each worker to join with it locally, avoiding expensive shuffles of the large dataset A.

Practice

1. What is the main purpose of broadcast variables in Apache Spark?

easy

A. To efficiently share small read-only data across all worker nodes

B. To store large datasets in memory on the driver node

C. To cache RDDs for faster repeated access

D. To shuffle data between partitions during a join

Solution

1. Step 1: Understand broadcast variable role

   Broadcast variables send a copy of small read-only data to all worker nodes once.

2. Step 2: Compare with other options

   Caching RDDs and shuffling data are different Spark features, not broadcast variables.

3. Final Answer:

   To efficiently share small read-only data across all worker nodes -> Option A

4. Quick Check:

   Broadcast variables = share small data efficiently [OK]

Hint: Broadcast = share small read-only data once [OK]

Common Mistakes:

• Confusing broadcast variables with caching
• Thinking broadcast variables handle large datasets
• Mixing broadcast variables with shuffle operations

2. Which of the following is the correct way to create a broadcast variable in PySpark?

easy

A. broadcastVar = sc.broadcast(data)

B. broadcastVar = SparkContext.broadcast(data)

C. broadcastVar = sc.broadcastVariable(data)

D. broadcastVar = sc.share(data)

Solution

1. Step 1: Recall PySpark broadcast syntax

   The correct method is calling broadcast() on SparkContext instance sc.

2. Step 2: Check other options

   Other options use incorrect method names or class calls.

3. Final Answer:

   broadcastVar = sc.broadcast(data) -> Option A

4. Quick Check:

   Use sc.broadcast() to create broadcast variable [OK]

Hint: Use sc.broadcast(data) to create broadcast variable [OK]

Common Mistakes:

• Using wrong method names like broadcastVariable
• Calling broadcast on SparkContext class instead of instance
• Trying to use sc.share() which doesn't exist

3. Given the following PySpark code, what will be the output?

data = {'a': 1, 'b': 2}
broadcastVar = sc.broadcast(data)
rdd = sc.parallelize(['a', 'b', 'c'])
result = rdd.map(lambda x: broadcastVar.value.get(x, 0)).collect()
print(result)

medium

A. [1, 2, None]

B. [0, 0, 0]

C. [1, 2]

D. [1, 2, 0]

Solution

1. Step 1: Understand broadcast variable usage in map

   The broadcast variable holds a dictionary. The map looks up each key in the dictionary, returning 0 if key not found.

2. Step 2: Evaluate each element in RDD

   'a' maps to 1, 'b' maps to 2, 'c' is missing so returns 0.

3. Final Answer:

   [1, 2, 0] -> Option D

4. Quick Check:

   Missing keys return 0, so output is [1, 2, 0] [OK]

Hint: Missing keys return default 0 in get() [OK]

Common Mistakes:

• Expecting None instead of 0 for missing keys
• Forgetting to use broadcastVar.value to access data
• Assuming output length matches dictionary size

4. Identify the error in this PySpark code snippet using broadcast variables:

data = [1, 2, 3]
broadcastVar = sc.broadcast(data)
rdd = sc.parallelize([1, 2, 3])
result = rdd.map(lambda x: broadcastVar.get(x)).collect()
print(result)

medium

A. The lambda function should not use broadcastVar

B. The broadcast variable should be created with sc.share()

C. broadcastVar.get() is not a valid method to access broadcast data

D. RDD should be created with sc.broadcast() instead of sc.parallelize()

Solution

1. Step 1: Check broadcast variable access method

   Broadcast variables are accessed via broadcastVar.value, not broadcastVar.get().

2. Step 2: Verify other parts of code

   sc.share() does not exist, and sc.parallelize() is correct for RDD creation.

3. Final Answer:

   broadcastVar.get() is not a valid method to access broadcast data -> Option C

4. Quick Check:

   Use broadcastVar.value to access data [OK]

Hint: Access broadcast data with .value, not .get() [OK]

Common Mistakes:

• Using broadcastVar.get() instead of broadcastVar.value
• Confusing RDD creation methods
• Trying to use non-existent sc.share() method

5. You have a large dataset of user logs and a small dictionary mapping user IDs to user names. You want to replace user IDs in the logs with names efficiently using broadcast variables. Which approach is best?

hard

A. Join the logs RDD with the user dictionary RDD using a shuffle join

B. Broadcast the user ID to name dictionary and map logs using broadcastVar.value.get()

C. Collect the logs RDD to driver and replace IDs locally

D. Use sc.broadcast() on the logs RDD to share it across workers

Solution

1. Step 1: Identify efficient use of broadcast variables

   Broadcast small user dictionary to all workers to avoid shuffling large logs data.

2. Step 2: Apply mapping using broadcast variable

   Use broadcastVar.value.get() in map to replace user IDs with names efficiently.

3. Step 3: Evaluate other options

   Shuffle join is expensive, collecting large logs to driver is inefficient, broadcasting large logs is incorrect.

4. Final Answer:

   Broadcast the user ID to name dictionary and map logs using broadcastVar.value.get() -> Option B

5. Quick Check:

   Broadcast small data, map large data [OK]

Hint: Broadcast small lookup data, map large dataset [OK]

Common Mistakes:

• Trying to broadcast large datasets
• Using shuffle join instead of broadcast
• Collecting large RDDs to driver causing memory issues