DSP benchmarking and profiling in Signal Processing - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to measure the execution time of a DSP function using a timer.

Signal Processing

start_time = [1]()
# DSP function call here
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Elapsed time: {elapsed_time} seconds")

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

Atime.clock

Btime.time

Ctime.now

Dtimer.start

Attempts:

3 left

💡 Hint

Common Mistakes

Using time.clock() which is deprecated.

Using time.now() which does not exist.

We use time.time() to get the current time in seconds since the epoch, which helps measure elapsed time.

2fill in blank

medium

Complete the code to calculate the average execution time over multiple runs.

Signal Processing

import time
runs = 5
total_time = 0
for _ in range(runs):
    start = time.time()
    dsp_process()
    end = [1]()
    total_time += end - start
average_time = total_time / runs
print(f"Average time: {average_time} seconds")

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

Atime.time

Btime.clock

Ctimer.now

Dtime.perf_counter

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing different timing functions for start and end.

Using non-existent functions like timer.now().

The end time should be captured with time.time() to match the start time measurement.

3fill in blank

hard

Fix the error in the code to correctly profile a DSP function using Python's timeit module.

Signal Processing

import timeit
code_to_test = '''
def dsp_func():
    # DSP processing code
    pass
'''
execution_time = timeit.timeit(stmt='dsp_func()', setup='from __main__ import dsp_func', number=[1])
print(f"Execution time for 100 runs: {execution_time} seconds")

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

Aone_hundred

B'100'

C100

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the number as a string causes a TypeError.

Using undefined variables like one_hundred.

The number parameter must be an integer, not a string.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps signal names to their lengths if length is greater than 100.

Signal Processing

signal_lengths = {name: [1] for name, data in signals.items() if [2] > 100}

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

Alen(data)

Bdata

Clen(name)

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(name) instead of len(data).

Checking the length of the name instead of the data.

We use len(data) to get the length of each signal's data and check if it is greater than 100.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase signal names to their max values if max value is above threshold.

Signal Processing

filtered_signals = [1]: [2] for [3], values in signals.items() if max(values) > threshold

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

Aname.upper()

Bmax(values)

Cname

Dvalues

Attempts:

3 left

💡 Hint

Common Mistakes

Using values as keys instead of name.upper().

Using name as values instead of max values.

The dictionary keys are uppercase signal names, values are max values, and iteration uses name and values.

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