tests/lldb/tests/testcases/test_reduction.py - platform/frameworks/rs - Git at Google

 # Copyright (C) 2016 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.

 from __future__ import absolute_import

 import itertools

 from harness.test_base_remote import TestBaseRemote
 from harness.decorators import (
     ordered_test,
     wimpy,
 )
 from harness.assert_mixins import CoordinateAssertionsMixin

 from reduce_common import (
     REDUCE_ITERATIONS,
     REDUCE_STARTVAL,
     REDUCE_SCRIPT,
     X_TESTS,
     Y_TESTS,
     Z_TESTS,
     ReductionMixin,
 )


 def coords_range_3d(x_range, y_range, z_range):
     count = max((x_range, y_range, z_range))
     x = itertools.cycle(range(x_range))
     y = itertools.cycle(range(y_range))
     z = itertools.cycle(range(z_range))
     return itertools.islice(
         itertools.izip(x, y, z),
         count
     )


 class TestReduce1DSingleThreaded(
         TestBaseRemote, CoordinateAssertionsMixin, ReductionMixin):
     """
     Reduction kernels for RenderScript are launched using
     a different `.expand` function than regular `ForEach` kernels and reflect a
     different API to the invoking program

     Although the debugger implementation for accessing these features tracks
     this slightly differently for reduction kernels, the user interface should
     still offer the basic functionality:
         - breakpoints on a coordinate
         - tracking, viewing and dumping allocations
         - listing modules and constituent kernels and types
     """

     bundle_target = {
         'java': 'Reduction',
     }

     def _delete_breakpoints(self):
         try:
             self.do_command('breakpoint delete -f')
         except self.TestFail:
             pass

     def setup(self, android):
         """This test requires to be run on one thread."""
         android.push_prop('debug.rs.max-threads', 1)

     def teardown(self, android):
         """Reset the number of RS threads to the previous value."""
         android.pop_prop('debug.rs.max-threads')

     @ordered_test(0)
     @wimpy
     def test_setup(self):
         self.try_command('language renderscript status', [])
         self.try_command('b find_min_user_type_accum', [])
         self.try_command('c', [])

     @ordered_test(1)
     @wimpy
     def test_renderscript_module_dump(self):
         """
         Generalised Reduction kernels for RenderScript are not tracked in the
         same way as `ForEach` kernels, and do not have `__attribute__((kernel))`
         so we need to make sure that when a module contains reduction kernels,
         `language renderscript module dump` in lldb prints the correct kernels.
         """
         self.try_command(
             'language renderscript module dump',
             [
                 'Reductions: 1',
                 'find_min_user_type',
                 'accumulator: find_min_user_type_accum',
                 'combiner: find_min_user_type_comb',
                 'outconverter: find_min_user_type_outc'
             ]
         )

     @ordered_test(2)
     @wimpy
     def test_module_dump_with_foreach_kernel_separate(self):
         """
         The reduction breakpoint is separate from that of a standard kernel
         function breakpoint, so we need to make sure that when we dump a module,
         reductions are properly collected and displayed alongside the standard
         __attribute__((kernel)) functions.
         Assert that `... module dump` can correctly distinguish between `reduce`
         kernels and `ForEach` kernels.
         """
         self.try_command(
             'language renderscript module dump',
             [
                 'Kernels: 2',
                 'Reductions: 1',
                 'accumulator: find_min_user_type_accum',
                 'initializer: find_min_user_type_init',
                 'combiner: find_min_user_type_comb',
                 'outconverter: find_min_user_type_outc'
             ]
         )

     @wimpy
     @ordered_test(3)
     def test_reduction_breakpoint_set_all_roles_resolved(self):
         """
         Assert that a reduction breakpoint successfully resolves all the
         functions that make up the reduction kernel
         """
         self.try_command(
             'language renderscript reduction breakpoint set find_min_user_type',
             ['Breakpoint(s) created']
         )

         self.try_command(
             'process continue',
             expected_regex=[
                 r'Process \d+ stopped',
                 r'librs.reduce.so`find_min_user_type',
                 r'stop reason = breakpoint'
             ]
         )
         name = REDUCE_SCRIPT
         self.try_command(
             'breakpoint list',
             expected_regex=[
                 "RenderScript reduce breakpoint for 'find_min_user_type', locations = 4, resolved = 4",
                 'where = librs.reduce.so`find_min_user_type_init (\+ \d+ )?at %s(.+, resolved,)' % name,
                 'where = librs.reduce.so`find_min_user_type_accum (\+ \d+ )?at %s(.+, resolved,)' % name,
                 'where = librs.reduce.so`find_min_user_type_comb (\+ \d+ )?at %s(.+, resolved,)' % name,
                 'where = librs.reduce.so`find_min_user_type_outc (\+ \d+ )?at %s(.+, resolved,)' % name,
             ]
         )

     @ordered_test(4)
     def test_reduce_iterations(self):
         """
         Given a reduction, we want to make sure that we break on
         every accumulator invocation before seeing the outconverter called.
         This requires the tests to be run single threaded
         """
         self._delete_breakpoints()
         self.try_command(
             'language renderscript reduction breakpoint set find_min_user_type -t initializer',
         )
         self.try_command(
             'process continue',
             expected_regex=[
                 r'Process \d+ stopped',
                 r'librs.reduce.so`find_min_user_type_init',
                 r'stop reason = breakpoint',
             ]
         )
         self._delete_breakpoints()

         self.try_command((
             'language renderscript reduction breakpoint '
             'set find_min_user_type --function-role accumulator,outconverter'),
             ['Breakpoint(s) created']
         )
         for i in range(REDUCE_ITERATIONS):
             self.try_command(
                 'process continue',
                 expected_regex=[
                     r'Process \d+ resuming',
                     r'Process \d+ stopped',
                     r'librs.reduce.so`find_min_user_type_accum',
                     r'stop reason = breakpoint'
                 ]
             )
             self.try_command('p val')
             self.try_command(
                 'p val.b',
                 expected_regex=[
                     r'^\((const )?int32_t\)\s*\$\d+ = %s\s*$' % (
                         i + REDUCE_STARTVAL)
                 ]
             )
         # We should then finally break on the outconverter
         self.try_command(
             'process continue',
             expected_regex=[
                 r'Process \d+ resuming',
                 r'Process \d+ stopped',
                 r'librs.reduce.so`find_min_user_type_outc',
                 r'stop reason = breakpoint'
             ]
         )

     @ordered_test(5)
     def test_function_role_breakpoints_combinations(self):
         func_role_combinations = itertools.combinations(
             ('accumulator', 'initializer'),
             r=2
         )
         self._test_func_role_combinations(func_role_combinations)

     @wimpy
     @ordered_test(6)
     def test_resolve_function_role_all_reduce_functions(self):
         """
         Assert that a reduction breakpoint successfully resolves all the
         functions that make up the reduction kernel when the parameter `all` is
         passed to `--function-role` for the breakpoint command
         """
         self._delete_breakpoints()
         self.try_command(
             'language renderscript reduction breakpoint set find_min_user_type -t all',
             [r'Breakpoint(s) created']
         )
         self.try_command('c', [])
         breakpoints_match = [
             r"where = librs.reduce.so`%s (\+ \d+ )?at %s:\d+, address = 0x[0-9a-fA-F]+, resolved" % (
                  'find_min_user_type_%s' % func_match,
                  REDUCE_SCRIPT
             )
             for func_match in ('accum', 'init', 'comb', 'outc')
         ]
         self.try_command(
             'breakpoint list',
             expected_regex=[
                 r"Current breakpoints:",
                 r"RenderScript reduce breakpoint for 'find_min_user_type', locations = 4, resolved = 4",
                 r"Names:",
                 r"RenderScriptReduction",
             ] + breakpoints_match
         )

     @ordered_test(8)
     def test_reduce_breakpoint_conditional_1d_coordinate(self):
         """
         Assert that breakpoints conditional on an allocation coordinate
         are only triggered on that coordinate
         """
         for x, _, __ in sorted(coords_range_3d(X_TESTS, Y_TESTS, Z_TESTS)):
             self._delete_breakpoints()
             self.assert_coord_bp_set(
                 'find_min_user_type -t accumulator',
                 x,
                 kernel_type='reduction'
             )
             self.assert_coord_stop('reduce', 'find_min_user_type', x)
             # Step *into* the function so locals are available
             # FIXME remove the need for `next` here; skip the function prologue
             self.try_command('n')
             self.try_command('p accum->a')
             self.try_command('p accum->b')

     @ordered_test('last')
     def test_exit(self):
         self.try_command('process kill', [])
	# Copyright (C) 2016 The Android Open Source Project
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.

	from __future__ import absolute_import

	import itertools

	from harness.test_base_remote import TestBaseRemote
	from harness.decorators import (
	ordered_test,
	wimpy,
	)
	from harness.assert_mixins import CoordinateAssertionsMixin

	from reduce_common import (
	REDUCE_ITERATIONS,
	REDUCE_STARTVAL,
	REDUCE_SCRIPT,
	X_TESTS,
	Y_TESTS,
	Z_TESTS,
	ReductionMixin,
	)


	def coords_range_3d(x_range, y_range, z_range):
	count = max((x_range, y_range, z_range))
	x = itertools.cycle(range(x_range))
	y = itertools.cycle(range(y_range))
	z = itertools.cycle(range(z_range))
	return itertools.islice(
	itertools.izip(x, y, z),
	count
	)


	class TestReduce1DSingleThreaded(
	TestBaseRemote, CoordinateAssertionsMixin, ReductionMixin):
	"""
	Reduction kernels for RenderScript are launched using
	a different `.expand` function than regular `ForEach` kernels and reflect a
	different API to the invoking program

	Although the debugger implementation for accessing these features tracks
	this slightly differently for reduction kernels, the user interface should
	still offer the basic functionality:
	- breakpoints on a coordinate
	- tracking, viewing and dumping allocations
	- listing modules and constituent kernels and types
	"""

	bundle_target = {
	'java': 'Reduction',
	}

	def _delete_breakpoints(self):
	try:
	self.do_command('breakpoint delete -f')
	except self.TestFail:
	pass

	def setup(self, android):
	"""This test requires to be run on one thread."""
	android.push_prop('debug.rs.max-threads', 1)

	def teardown(self, android):
	"""Reset the number of RS threads to the previous value."""
	android.pop_prop('debug.rs.max-threads')

	@ordered_test(0)
	@wimpy
	def test_setup(self):
	self.try_command('language renderscript status', [])
	self.try_command('b find_min_user_type_accum', [])
	self.try_command('c', [])

	@ordered_test(1)
	@wimpy
	def test_renderscript_module_dump(self):
	"""
	Generalised Reduction kernels for RenderScript are not tracked in the
	same way as `ForEach` kernels, and do not have `__attribute__((kernel))`
	so we need to make sure that when a module contains reduction kernels,
	`language renderscript module dump` in lldb prints the correct kernels.
	"""
	self.try_command(
	'language renderscript module dump',
	[
	'Reductions: 1',
	'find_min_user_type',
	'accumulator: find_min_user_type_accum',
	'combiner: find_min_user_type_comb',
	'outconverter: find_min_user_type_outc'
	]
	)

	@ordered_test(2)
	@wimpy
	def test_module_dump_with_foreach_kernel_separate(self):
	"""
	The reduction breakpoint is separate from that of a standard kernel
	function breakpoint, so we need to make sure that when we dump a module,
	reductions are properly collected and displayed alongside the standard
	__attribute__((kernel)) functions.
	Assert that `... module dump` can correctly distinguish between `reduce`
	kernels and `ForEach` kernels.
	"""
	self.try_command(
	'language renderscript module dump',
	[
	'Kernels: 2',
	'Reductions: 1',
	'accumulator: find_min_user_type_accum',
	'initializer: find_min_user_type_init',
	'combiner: find_min_user_type_comb',
	'outconverter: find_min_user_type_outc'
	]
	)

	@wimpy
	@ordered_test(3)
	def test_reduction_breakpoint_set_all_roles_resolved(self):
	"""
	Assert that a reduction breakpoint successfully resolves all the
	functions that make up the reduction kernel
	"""
	self.try_command(
	'language renderscript reduction breakpoint set find_min_user_type',
	['Breakpoint(s) created']
	)

	self.try_command(
	'process continue',
	expected_regex=[
	r'Process \d+ stopped',
	r'librs.reduce.so`find_min_user_type',
	r'stop reason = breakpoint'
	]
	)
	name = REDUCE_SCRIPT
	self.try_command(
	'breakpoint list',
	expected_regex=[
	"RenderScript reduce breakpoint for 'find_min_user_type', locations = 4, resolved = 4",
	'where = librs.reduce.so`find_min_user_type_init (\+ \d+ )?at %s(.+, resolved,)' % name,
	'where = librs.reduce.so`find_min_user_type_accum (\+ \d+ )?at %s(.+, resolved,)' % name,
	'where = librs.reduce.so`find_min_user_type_comb (\+ \d+ )?at %s(.+, resolved,)' % name,
	'where = librs.reduce.so`find_min_user_type_outc (\+ \d+ )?at %s(.+, resolved,)' % name,
	]
	)

	@ordered_test(4)
	def test_reduce_iterations(self):
	"""
	Given a reduction, we want to make sure that we break on
	every accumulator invocation before seeing the outconverter called.
	This requires the tests to be run single threaded
	"""
	self._delete_breakpoints()
	self.try_command(
	'language renderscript reduction breakpoint set find_min_user_type -t initializer',
	)
	self.try_command(
	'process continue',
	expected_regex=[
	r'Process \d+ stopped',
	r'librs.reduce.so`find_min_user_type_init',
	r'stop reason = breakpoint',
	]
	)
	self._delete_breakpoints()

	self.try_command((
	'language renderscript reduction breakpoint '
	'set find_min_user_type --function-role accumulator,outconverter'),
	['Breakpoint(s) created']
	)
	for i in range(REDUCE_ITERATIONS):
	self.try_command(
	'process continue',
	expected_regex=[
	r'Process \d+ resuming',
	r'Process \d+ stopped',
	r'librs.reduce.so`find_min_user_type_accum',
	r'stop reason = breakpoint'
	]
	)
	self.try_command('p val')
	self.try_command(
	'p val.b',
	expected_regex=[
	r'^\((const )?int32_t\)\s\$\d+ = %s\s$' % (
	i + REDUCE_STARTVAL)
	]
	)
	# We should then finally break on the outconverter
	self.try_command(
	'process continue',
	expected_regex=[
	r'Process \d+ resuming',
	r'Process \d+ stopped',
	r'librs.reduce.so`find_min_user_type_outc',
	r'stop reason = breakpoint'
	]
	)

	@ordered_test(5)
	def test_function_role_breakpoints_combinations(self):
	func_role_combinations = itertools.combinations(
	('accumulator', 'initializer'),
	r=2
	)
	self._test_func_role_combinations(func_role_combinations)

	@wimpy
	@ordered_test(6)
	def test_resolve_function_role_all_reduce_functions(self):
	"""
	Assert that a reduction breakpoint successfully resolves all the
	functions that make up the reduction kernel when the parameter `all` is
	passed to `--function-role` for the breakpoint command
	"""
	self._delete_breakpoints()
	self.try_command(
	'language renderscript reduction breakpoint set find_min_user_type -t all',
	[r'Breakpoint(s) created']
	)
	self.try_command('c', [])
	breakpoints_match = [
	r"where = librs.reduce.so`%s (\+ \d+ )?at %s:\d+, address = 0x[0-9a-fA-F]+, resolved" % (
	'find_min_user_type_%s' % func_match,
	REDUCE_SCRIPT
	)
	for func_match in ('accum', 'init', 'comb', 'outc')
	]
	self.try_command(
	'breakpoint list',
	expected_regex=[
	r"Current breakpoints:",
	r"RenderScript reduce breakpoint for 'find_min_user_type', locations = 4, resolved = 4",
	r"Names:",
	r"RenderScriptReduction",
	] + breakpoints_match
	)

	@ordered_test(8)
	def test_reduce_breakpoint_conditional_1d_coordinate(self):
	"""
	Assert that breakpoints conditional on an allocation coordinate
	are only triggered on that coordinate
	"""
	for x, _, __ in sorted(coords_range_3d(X_TESTS, Y_TESTS, Z_TESTS)):
	self._delete_breakpoints()
	self.assert_coord_bp_set(
	'find_min_user_type -t accumulator',
	x,
	kernel_type='reduction'
	)
	self.assert_coord_stop('reduce', 'find_min_user_type', x)
	# Step into the function so locals are available
	# FIXME remove the need for `next` here; skip the function prologue
	self.try_command('n')
	self.try_command('p accum->a')
	self.try_command('p accum->b')

	@ordered_test('last')
	def test_exit(self):
	self.try_command('process kill', [])