Input splits and data locality in Hadoop - Mini Project: Build & Apply

Understanding Input Splits and Data Locality in Hadoop

📖 Scenario: You are working with a large text file stored in Hadoop Distributed File System (HDFS). You want to understand how Hadoop divides this file into input splits and how data locality helps improve processing speed.

🎯 Goal: Build a simple Hadoop MapReduce job setup that shows how input splits are created and how data locality is determined for processing.

📋 What You'll Learn

Create a sample input file path variable

Set a split size configuration variable

Write code to calculate input splits based on file size and split size

Print the number of splits and their data locality information

💡 Why This Matters

🌍 Real World

Hadoop processes huge data files by splitting them into chunks called input splits. This helps distribute work across many computers.

💼 Career

Understanding input splits and data locality is important for optimizing big data jobs and improving processing speed in data engineering roles.

1

Create the input file path and file size

Create a variable called input_file_path and set it to "/user/hadoop/input/largefile.txt". Also create a variable called file_size_bytes and set it to 134217728 (which is 128 MB).

Hadoop

# Create variables for input file path and file size
# Your code here

Hint

Use simple assignment to create input_file_path and file_size_bytes variables.

2

Set the split size configuration

Create a variable called split_size_bytes and set it to 33554432 (which is 32 MB).

Hadoop

input_file_path = "/user/hadoop/input/largefile.txt"
file_size_bytes = 134217728
# Set the split size in bytes
# Your code here

Hint

Set split_size_bytes to 32 MB in bytes.

3

Calculate the number of input splits

Create a variable called num_splits that calculates how many splits the file will be divided into. Use integer division and add 1 if there is a remainder. Use file_size_bytes and split_size_bytes.

Hadoop

input_file_path = "/user/hadoop/input/largefile.txt"
file_size_bytes = 134217728
split_size_bytes = 33554432
# Calculate number of splits
# Your code here

Hint

Use integer division // and modulo % to calculate splits.

4

Print the number of splits and data locality info

Print the text "Number of input splits:" followed by num_splits. Then print "Data locality helps run tasks on nodes where data is stored.".

Hadoop

input_file_path = "/user/hadoop/input/largefile.txt"
file_size_bytes = 134217728
split_size_bytes = 33554432
num_splits = file_size_bytes // split_size_bytes + (1 if file_size_bytes % split_size_bytes != 0 else 0)
# Print number of splits and data locality info
# Your code here

Hint

Use two print statements to show the results.

Practice

1. What is the main purpose of input splits in Hadoop?

easy

A. To compress data files for storage efficiency

B. To backup data to multiple locations

C. To encrypt data for security

D. To divide large data into smaller chunks for parallel processing

Solution

1. Step 1: Understand input splits concept

   Input splits break large data into smaller parts so multiple tasks can process them at the same time.

2. Step 2: Compare options with input splits purpose

   Only dividing data for parallel processing matches the input splits function.

3. Final Answer:

   To divide large data into smaller chunks for parallel processing -> Option D

4. Quick Check:

   Input splits = divide data for parallel tasks [OK]

Hint: Input splits break data for parallel work [OK]

Common Mistakes:

• Confusing input splits with data compression
• Thinking input splits encrypt data
• Mixing input splits with backup processes

2. Which of the following is the correct way to describe data locality in Hadoop?

easy

A. Running tasks close to where data is stored to reduce network traffic

B. Running tasks on nodes far from the data to balance load

C. Copying data to all nodes before processing

D. Encrypting data before processing

Solution

1. Step 1: Define data locality

   Data locality means running processing tasks near the data location to save time and network resources.

2. Step 2: Match definition with options

   Only Running tasks close to where data is stored to reduce network traffic describes running tasks close to data to reduce network traffic.

3. Final Answer:

   Running tasks close to where data is stored to reduce network traffic -> Option A

4. Quick Check:

   Data locality = run tasks near data [OK]

Hint: Data locality means processing near data location [OK]

Common Mistakes:

• Thinking data locality means copying data everywhere
• Confusing data locality with encryption
• Believing tasks run far from data for load balancing

3. Consider a Hadoop job processing a 128 MB file with a default block size of 64 MB. How many input splits will Hadoop create by default?

medium

A. 2

B. 128

C. 64

D. 1

Solution

1. Step 1: Understand block size and file size relation

   The file is 128 MB and block size is 64 MB, so the file fits into two blocks.

2. Step 2: Determine number of input splits

   By default, Hadoop creates one input split per block, so 2 splits for 2 blocks.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   File size / block size = input splits [OK]

Hint: Input splits = file size ÷ block size [OK]

Common Mistakes:

• Assuming one split regardless of file size
• Confusing block size with split size
• Choosing number equal to file size in MB

4. A Hadoop job is running slower than expected. The developer suspects data locality is not being used. Which of the following could fix this issue?

medium

A. Increase the number of input splits to one per byte

B. Configure the job to prefer running tasks on nodes where data blocks reside

C. Disable input splits to process the whole file at once

D. Compress the input data before processing

Solution

1. Step 1: Identify cause of slow job

   Slow job may be due to tasks running far from data, causing network delays.

2. Step 2: Choose fix to improve data locality

   Configuring the job to run tasks on nodes holding data blocks improves data locality and speed.

3. Final Answer:

   Configure the job to prefer running tasks on nodes where data blocks reside -> Option B

4. Quick Check:

   Improve data locality by running tasks near data [OK]

Hint: Run tasks on nodes with data blocks to speed up [OK]

Common Mistakes:

• Increasing splits too much causes overhead
• Disabling splits reduces parallelism
• Compressing data doesn't fix locality

5. You have a Hadoop cluster with 4 nodes. A 256 MB file is stored with a block size of 64 MB. If one node fails, how does Hadoop maintain data locality and processing efficiency?

hard

A. It processes all data on a single node ignoring data locality

B. It stops the job until the failed node is fixed

C. It reassigns input splits to nodes holding replica blocks to keep tasks near data

D. It deletes the missing blocks and continues with remaining data

Solution

1. Step 1: Understand Hadoop replication and fault tolerance

   Hadoop stores multiple copies (replicas) of each block on different nodes to handle failures.

2. Step 2: How Hadoop maintains data locality after node failure

   When a node fails, Hadoop schedules tasks on nodes that have replica blocks to keep data locality and efficiency.

3. Final Answer:

   It reassigns input splits to nodes holding replica blocks to keep tasks near data -> Option C

4. Quick Check:

   Replica blocks keep data local despite node failure [OK]

Hint: Hadoop uses replicas to keep data local if node fails [OK]

Common Mistakes:

• Thinking job stops on node failure
• Assuming data is processed on one node only
• Believing missing blocks are deleted immediately