Input splits and data locality in Hadoop - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create input splits for a file in Hadoop.

Hadoop

FileInputFormat.addInputPath(job, new Path([1]));

Drag options to blanks, or click blank then click option'

Ajob

B"inputfile.txt"

C"/user/data/input"

Dnew Path()

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the job object instead of a path string.

Not using quotes around the path string.

The addInputPath method requires a Path object pointing to the input directory or file. Here, "/user/data/input" is the correct path string.

2fill in blank

medium

Complete the code to get the number of input splits from the job context.

Hadoop

List<InputSplit> splits = inputFormat.getSplits([1]);

Drag options to blanks, or click blank then click option'

Ajob

Bcontext

Cconfiguration

DinputFormat

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the inputFormat object itself.

Passing an unrelated variable like context.

The getSplits method requires the JobContext or Job object to generate splits. Here, job is the correct argument.

3fill in blank

hard

Fix the error in the code to ensure data locality is considered when processing splits.

Hadoop

for (InputSplit split : splits) {
    String[] locations = split.getLocations();
    if (locations.length > [1]) {
        System.out.println("Data is local to node: " + locations[0]);
    }
}

Drag options to blanks, or click blank then click option'

A1

B0

C-1

Dlocations.length

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if length > 1 which skips cases with exactly one location.

Using negative numbers in the condition.

The condition should check if there is at least one location, so the length must be greater than 0.

4fill in blank

hard

Fill both blanks to create a map of split locations and their corresponding split sizes.

Hadoop

Map<String, Long> splitSizes = new HashMap<>();
for (InputSplit split : splits) {
    String[] locations = split.getLocations();
    long size = split.[1]();
    for (String loc : locations) {
        splitSizes.put(loc, splitSizes.getOrDefault(loc, [2]) + size);
    }
}

Drag options to blanks, or click blank then click option'

AgetLength

B0L

CgetSize

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using getSize() which does not exist.

Using null as default value causing errors.

The method to get the size of an InputSplit is getLength(). The default value for the map when a location is not present should be 0L (zero as a long).

5fill in blank

hard

Fill all three blanks to filter input splits larger than 128MB and print their first location.

Hadoop

for (InputSplit split : splits) {
    if (split.[1]() > [2]) {
        String[] locs = split.[3]();
        if (locs.length > 0) {
            System.out.println("Large split at: " + locs[0]);
        }
    }
}

Drag options to blanks, or click blank then click option'

AgetLength

B134217728

CgetLocations

DgetSize

Attempts:

3 left

💡 Hint

Common Mistakes

Using getSize() which is not a valid method.

Using incorrect byte value for 128MB.

Confusing getLocations() with other methods.

getLength() returns the size of the split in bytes. 128MB equals 134,217,728 bytes. getLocations() returns the array of nodes where the split data is located.

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