DSP benchmarking and profiling in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Measuring Execution Time of a DSP Filter Function

Consider the following Python code that applies a simple moving average filter to a signal. What is the output of the print statement showing the elapsed time?

Signal Processing

import time
import numpy as np

def moving_average(signal, window_size):
    return np.convolve(signal, np.ones(window_size)/window_size, mode='valid')

signal = np.random.rand(1000000)
start = time.perf_counter()
filtered = moving_average(signal, 10)
elapsed = time.perf_counter() - start
print(f"Elapsed time: {elapsed:.4f} seconds")

A Elapsed time: 0.1 seconds

B Elapsed time: 0.01 seconds

C Elapsed time: 0.0001 seconds

D Elapsed time: 10.0 seconds

💡 Hint

Think about the time complexity of convolution on a large array.

The moving average uses convolution on a 1 million element array with a window of 10. This typically takes around a tenth of a second on a modern CPU.

❓ data_output

intermediate

Profiling Memory Usage of a DSP Operation

Given the following code that creates a large signal and applies a Fourier transform, what is the approximate peak memory usage increase during the FFT operation?

Signal Processing

import numpy as np
signal = np.random.rand(10**7)
# Assume memory profiler measures peak memory during fft
fft_result = np.fft.fft(signal)

A About 160 MB increase

B About 80 MB increase

C About 320 MB increase

D About 640 MB increase

💡 Hint

Consider the size of the input array and the data type used by numpy.

The input array of 10 million floats (float64) uses about 80 MB. The FFT output is complex128, which uses twice the memory, so peak memory increases by about 160 MB.

❓ visualization

advanced

Interpreting a Profiling Flame Graph for DSP Code

You run a profiler on a DSP algorithm and get a flame graph showing function call times. Which function is the main bottleneck if it occupies the widest block at the bottom of the graph?

A The function at the top of the graph

B The function with the narrowest block

C The function in the middle of the graph

D The function at the bottom of the graph

💡 Hint

In flame graphs, wider blocks mean more time spent.

The bottom function with the widest block represents the function consuming the most time, thus the main bottleneck.

🧠 Conceptual

advanced

Choosing the Best Metric for DSP Algorithm Benchmarking

Which metric is most appropriate to compare the efficiency of two DSP algorithms performing the same task on the same hardware?

A Number of lines of code

B Amount of comments in the code

C Execution time measured by a high-resolution timer

D Number of functions called

💡 Hint

Think about what directly measures speed.

Execution time measured by a high-resolution timer directly reflects how fast the algorithm runs, making it the best metric for efficiency comparison.

🔧 Debug

expert

Identifying the Cause of Inconsistent DSP Benchmark Results

A DSP engineer notices that repeated runs of the same benchmark code produce varying execution times. Which of the following is the most likely cause?

A The code has a syntax error causing random delays

B CPU frequency scaling and background processes affect timing

C The input signal changes between runs

D The output data type is inconsistent

💡 Hint

Consider system-level factors affecting timing consistency.

CPU frequency scaling and background processes cause variability in execution time by changing CPU speed and resource availability.

Practice

1. What is the main purpose of benchmarking in DSP (Digital Signal Processing)?

easy

A. To find bugs in DSP code

B. To measure how fast DSP tasks run

C. To visualize signal waveforms

D. To store DSP data efficiently

Solution

1. Step 1: Understand benchmarking in DSP context

   Benchmarking is used to measure the speed or performance of DSP tasks.

2. Step 2: Compare options with definition

   Only To measure how fast DSP tasks run correctly describes benchmarking as measuring speed.

3. Final Answer:

   To measure how fast DSP tasks run -> Option B

4. Quick Check:

   Benchmarking = speed measurement [OK]

Hint: Benchmarking = speed test of DSP tasks [OK]

Common Mistakes:

• Confusing benchmarking with debugging
• Thinking benchmarking visualizes data
• Mixing benchmarking with data storage

2. Which Python code snippet correctly measures the execution time of a DSP function process_signal() using time module?

easy

A. start = time.time()
process_signal()
end = time.time()
print(end - start)

B. start = time()
process_signal()
print(time - start)

C. time.start()
process_signal()
time.end()
print(time.duration())

D. process_signal()
start = time.time()
end = time.time()
print(end - start)

Solution

1. Step 1: Identify correct usage of time module

   Correct usage is to call time.time() before and after the function, then subtract.

2. Step 2: Check each option

   start = time.time() process_signal() end = time.time() print(end - start) correctly calls time.time() before and after, then prints difference. Others have syntax errors or wrong order.

3. Final Answer:

   start = time.time()\nprocess_signal()\nend = time.time()\nprint(end - start) -> Option A

4. Quick Check:

   time.time() before and after = start = time.time() process_signal() end = time.time() print(end - start) [OK]

Hint: Use time.time() before and after function call [OK]

Common Mistakes:

• Calling time functions incorrectly
• Measuring time after function runs
• Using undefined time methods

3. Given the Python code below, what will be the output?

import time

def filter_signal():
    time.sleep(0.1)

start = time.time()
filter_signal()
end = time.time()
print(round(end - start, 1))

medium

A. 0.0

B. Error

C. 0.1

D. 1.0

Solution

1. Step 1: Understand time.sleep(0.1) effect

   The function pauses execution for 0.1 seconds.

2. Step 2: Calculate elapsed time

   Elapsed time is about 0.1 seconds, rounded to 1 decimal place gives 0.1.

3. Final Answer:

   0.1 -> Option C

4. Quick Check:

   Sleep 0.1 sec = output 0.1 [OK]

Hint: Sleep time equals measured time rounded [OK]

Common Mistakes:

• Ignoring rounding effect
• Confusing sleep duration with output
• Expecting zero or error output

4. The following code is intended to profile which part of DSP code takes the most time. What is the error?

import cProfile

def process():
    step1()
    step2()

cProfile.run('process()')

medium

A. Missing definitions of step1() and step2() functions

B. cProfile.run() cannot profile functions

C. process() should be called before cProfile.run()

D. cProfile requires import time module

Solution

1. Step 1: Check function definitions

   step1() and step2() are called but not defined, causing NameError.

2. Step 2: Verify cProfile usage

   cProfile.run() can profile functions by passing string, so usage is correct.

3. Final Answer:

   Missing definitions of step1() and step2() functions -> Option A

4. Quick Check:

   Undefined functions cause error [OK]

Hint: Ensure all called functions are defined before profiling [OK]

Common Mistakes:

• Assuming cProfile.run() needs prior function call
• Thinking cProfile needs time module
• Ignoring missing function definitions

5. You want to improve a DSP filter's performance by profiling. After profiling, you find that 70% of time is spent in a nested loop filtering step. What is the best next step to optimize performance?

hard

A. Ignore profiling results and optimize other unrelated parts

B. Add more print statements inside the nested loop to monitor progress

C. Increase the input signal size to test scalability

D. Rewrite the nested loop using vectorized operations or optimized libraries

Solution

1. Step 1: Analyze profiling result

   Most time is spent in nested loop filtering step, so focus optimization there.

2. Step 2: Choose optimization method

   Using vectorized operations or optimized libraries reduces loop overhead and speeds up processing.

3. Final Answer:

   Rewrite the nested loop using vectorized operations or optimized libraries -> Option D

4. Quick Check:

   Optimize hotspot with vectorization = Rewrite the nested loop using vectorized operations or optimized libraries [OK]

Hint: Optimize code hotspot with vectorization or libraries [OK]

Common Mistakes:

• Adding print statements slows code
• Testing larger inputs before fixing bottleneck
• Ignoring profiling data