def run_kernel(src_code, image_src, block_size, args, nr_reg = 8, no_sequencer=True):
	''' Run a kernel, this assumes that the output is in buffer #1 and output is unscaled float. '''
	code = compile_code(src_code, args, block_size, nr_reg, no_sequencer)

	sim = Interpreter(code, image_src, block_size, 4, nr_reg)
	sim.run_kernel()
	return sim.gen_output_image(1, False, False, False)
def test_full_integral_image_correctness():
	''' Test generated full integral image correctness,
	    note that this relies on the corectness of interpreter and reference.py '''

	block_size = (20, 20)
	size = tuple(x*3 for x in block_size)

	# generate random test image
	test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])]

	# reference implementation
	integral_ref = reference.gen_integral_image(test_image)
	sq_integral_ref = reference.gen_integral_squared_image(test_image)

	# pointer config
	buffer_size = block_size[0]*block_size[1]
	src_ptr = 0
	integral_ptr = buffer_size
	sq_integral_ptr = 2*buffer_size

	# set up interpreter for integral image calculation
	pe_dim = [s//b for s, b in zip(size, block_size)]
	def code_gen(code, block_size, args):
		return gen_code.gen_full_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, pe_dim, block_size)
	code = Code()
	code.set_generator(optimiser_wrapper(code_gen), block_size)

	sim = Interpreter(code, test_image, block_size)
	sim.run()

	# get result of simulator with scaling, truncation turned off and float output
	integral_test = sim.gen_output_image(1, False, False, True)
	sq_integral_test = sim.gen_output_image(2, False, False, True)

	# comparison of reference with blip sim
	integral_err = compare_images(integral_ref, integral_test)
	sq_integral_err = compare_images(sq_integral_ref, sq_integral_test)

	err_eps = 0.001
	if not ((integral_err < err_eps) and (sq_integral_err < err_eps)):
		print 'integral comp:', integral_err
		print 'squared integral comp:', sq_integral_err
		
		print 'rendering instruction stream to file, can take a while'
		try:
			f = open('unoptimised_full_integral_image_trace.txt', 'w')
			def tag_str(instr): return ', '.join(instr.tag) if hasattr(instr, 'tag') else ''
			f.write('\n'.join(str(x).ljust(40) + ' tags: ' + tag_str(x) for x in code_gen(Code())))
			f.close()

			optim_gen = optimiser_wrapper(code_gen, block_size, {})
			f = open('bad_full_integral_image_trace.txt', 'w')
			def tag_str(instr): return ', '.join(instr.tag) if hasattr(instr, 'tag') else ''
			f.write('\n'.join(str(x).ljust(40) + ' tags: ' + tag_str(x) for x in optim_gen(Code())))
			f.close()
		except Exception, e:
			print 'could render instruction stream to file'
			print 'err: ' + str(e)
		
		assert False
def test_lid():
    block_size = (2, 2)
    def test_code(code, block_size, args):
        yield Imm(code.r(7), 0)
        yield Lid(code.r(0), code.r(7))
        yield Imm(code.r(6), 1)
        yield Lid(code.r(1), code.r(6))
        yield Imm(code.r(6), block_size[0])
        yield Mul(code.r(0), code.r(0), code.r(6))
        yield Add(code.r(0), code.r(1), code.r(0))
        yield MemW(code.r(0), code.r(0))

    code = Code()
    code.set_generator(test_code, block_size)
    print str(code)

    image = zeros(block_size[1], block_size[0])
    sim = Interpreter(code, image, block_size)
    sim.run_kernel()

    out_image = sim.gen_output_image(0, False)
    width, height = block_size
    for i in xrange(height):
        for j in xrange(width):
            assert out_image[i][j] == (i*width + j)
	def run_test(image, position, shape, block_size):
		def code_gen(code, block_size, args):
			return gen_code.gen_fullintegral_sum(code, code.r(4), position, shape, ptr, block_size)
		code = Code()
		code.set_generator(optimiser_wrapper(code_gen), block_size)

		sim = Interpreter(code, image, block_size)
		sim.run()
		# extract value
		return sim.procs[0][0].get_reg_by_name('r4')
	def run_test(image, position, shape, block_size):
		code = Code()
		out_reg = code.alloc_reg()
		def code_gen(code, block_size, args): 
			return gen_code.gen_integral_sum(code, out_reg, position, shape, ptr, block_size)
		code.set_generator(optimiser_wrapper(code_gen), block_size)

		sim = Interpreter(code, image, block_size)
		sim.run()
		# extract value
		return sim.procs[0][0].get_reg_by_name(str(out_reg))
Exemple #6
0
	def run_test(image, coeff):
		code = Code()
		block_size = (16, 16)
		in_ptr = 0
		out_ptr = block_size[0]*block_size[1]
		args = {}
		def codegen(code, block_size, args):
			return map_neighborhood_to_pixel(code, in_ptr, out_ptr, coeff, pixel_op, args, block_size)
		code.set_generator(codegen, block_size, args)
		sim = Interpreter(code, image, block_size)
		sim.run()
		return sim.gen_output_image(1)
Exemple #7
0
    def run_test(image, args, block_size):
        im_size = len(image[0]), len(image)
        bwidth, bheight = block_size
        assert(im_size == block_size) # only one pe

        code = Code()
        code.set_generator(codegen, block_size, args)

        sim = Interpreter(code, image, block_size)
        sim.run()
        output = sim.gen_output_image(1, False)
        return output
Exemple #8
0
	def run_test(image, offset):
		code = Code()
		block_size = (16, 16)
		in_ptr = 0
		out_ptr = block_size[0]*block_size[1]
		args = {'offset' : offset}
		def codegen(code, block_size, args):
			return map_image_to_pixel(code, in_ptr, out_ptr, pixel_op, args, block_size)
		code.set_generator(codegen, block_size, args)
		sim = Interpreter(code, image, block_size)
		sim.run()
		return sim.gen_output_image(1)
Exemple #9
0
    def run_test(images, th, alpha, block_size):
        image0 = images[0]
        im_size = len(image0)
        bwidth, bheight = block_size
        assert(im_size == bwidth * bheight) # only one pe

        code = Code()
        code.set_generator(gen_bbs, block_size, {'th':th, 'alpha':alpha})

        output = []
        sim = None
        for im in images:
            # interpreter expects 2D array
            im_tr = [[im[i*width + j] for j in xrange(bwidth)] for i in xrange(bheight)]
            if not sim:
                sim = Interpreter(code, im_tr, block_size)
            else:
                # restart code gen
                sim.reset()
                # set new image
                sim.set_src_image(im_tr)
            sim.run()
            im_out = sim.gen_output_image(1)
            # convert to 1D vector
            im_out_1D = []
            for row in im_out:
                for v in row:
                    im_out_1D.append(v)
            output.append(im_out_1D)
        return output
	def run_test(image, position, shape, ptr, block_size):
		px, py = position
		x, y, w, h = shape
		xx = px + x
		yy = py + y
		points =  ((xx, yy), (xx+w-1, yy), (xx, yy+h-1), (xx+w-1, yy+h-1))

		def code_gen(code, block_size, args): return gen_code.gen_fullintegral_sum2_2(code, code.r(4), ptr, points, block_size)
		code = Code()
		code.set_generator(code_gen, block_size)

		sim = Interpreter(code, image, block_size)
		sim.run()
		# extract value
		return sim.procs[0][0].get_reg_by_name('r4')
def test_sleep_wakeup():
    ''' Test sleep and wakeup opcodes. '''
    block_size = (2, 2)
    def test_code(code, block_size, args):
        yield Imm(code.r(0), 1)
        yield Sleep()
        yield Imm(code.r(0), 2)
        yield WakeUp()

    code = Code()
    code.set_generator(test_code, block_size)
    print str(code)

    image = zeros(block_size[1], block_size[0])
    sim = Interpreter(code, image, block_size)
    sim.run_kernel()
    # second imm should not be executed
    assert sim.procs[0][0].get_reg_by_name('r0') == 1
def gen_integral_image_correctness():
	''' test if generated integral image is correct, 
	    note that this relies on the corectness of interpreter and reference.py '''

#		size = (120, 80)
#		block_size = (40, 40)
	size = (80, 80)
	block_size = size 

	# generate random test image
	test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])]

	# reference implementation
	integral_ref = reference.gen_integral_image(test_image)
	sq_integral_ref = reference.gen_integral_squared_image(test_image)
	
	# pointer config
	buffer_size = block_size[0]*block_size[1]
	src_ptr = 0
	integral_ptr = buffer_size
	sq_integral_ptr = 2*buffer_size

	# set up interpreter for integral image calculation
	def code_gen(code, block_size, args):
		return gen_code.gen_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, block_size)
	code = Code()
	code.set_generator(optimiser_wrapper(code_gen), block_size)

	sim = Interpreter(code, test_image, block_size)
	sim.run()

	# get result of simulator with scaling, truncation turned off and float output
	integral_test = sim.gen_output_image(1, False, False, True)
	sq_integral_test = sim.gen_output_image(2, False, False, True)

	# comparison of reference with blip sim
	integral_err = compare_images(integral_ref, integral_test)
	sq_integral_err = compare_images(sq_integral_ref, sq_integral_test)

	err_eps = 0.001
	if not ((integral_err < err_eps) and (sq_integral_err < err_eps)):
		print 'integral comp:', integral_err
		print 'squared integral comp:', sq_integral_err 
		assert False
	def run_test(image, cascade):
		block_size = (64, 64)

		print 'XXX histogram equalisation is not implemented yet, use violajones impl'
		print '    before executing simulator'
		image = reference.equalizeHist(image)

		args = {'haar_classifier':cascade}
		# now execute the codegen
		code = Code()
		code.set_generator(gen_code.gen_detect_faces_opt, block_size, args)
		#print '# instructions: %i'%(code.instr_size())

		sim = Interpreter(code, image, block_size, 4)
		sim.run()

		detections_pixmap = sim.gen_output_image(1) # result is saved in first buffer

		# convert the number of rejections in the stages to detections
		detections = gen_code.convert_pixelmap_to_detections(detections_pixmap, cascade.size)
		return detections
def test_full_integral_image_correctness():
	''' Test generated full integral image correctness,
	    note that this relies on the correctness of interpreter and reference.py '''

	block_size = (20, 20)
	size = tuple(x*3 for x in block_size)

	# generate random test image
	test_image = [[float(random.randint(0, 255)) for i in xrange(size[0])] for j in xrange(size[1])]

	# reference implementation
	integral_ref = reference.gen_integral_image(test_image)
	sq_integral_ref = reference.gen_integral_squared_image(test_image)

	# pointer config
	buffer_size = block_size[0]*block_size[1]
	src_ptr = 0
	integral_ptr = buffer_size
	sq_integral_ptr = 2*buffer_size

	# set up interpreter for integral image calculation
	pe_dim = [s//b for s, b in zip(size, block_size)]
	code = Code()
	def code_gen(code, block_size, args): 
		return gen_code.gen_full_integral_image(code, src_ptr, integral_ptr, sq_integral_ptr, pe_dim, block_size)
	code.set_generator(code_gen, block_size)

	sim = Interpreter(code, test_image, block_size)
	sim.run()

	# get result of simulator with scaling, truncation turned off and float output
	integral_test = sim.gen_output_image(1, False, False, True)
	sq_integral_test = sim.gen_output_image(2, False, False, True)

	# comparison of reference with blip sim
	integral_err = compare_images(integral_ref, integral_test)
	sq_integral_err = compare_images(sq_integral_ref, sq_integral_test)

	err_eps = 0.001
	assert (integral_err < err_eps) and (sq_integral_err < err_eps)
def test_sleep_wakeup2():
    ''' Test sleep and wakeup opcodes. '''
    block_size = (2, 2)
    def test_code_sleep(code, block_size, args):
        yield Sleep()

    code = Code()
    code.set_generator(test_code_sleep, block_size)

    image = zeros(block_size[1], block_size[0])
    sim = Interpreter(code, image, block_size)

    # check if attribute is correct
    assert sim.procs[0][0].is_powerdown() == False
    sim.run_kernel()
    assert sim.procs[0][0].is_powerdown() == True

    # check if attribute is correct after wakeup
    def test_code_sleep_wakeup(code, block_size, args):
        yield Sleep()
        yield WakeUp()
    code2 = Code()
    code2.set_generator(test_code_sleep_wakeup, block_size)

    sim2 = Interpreter(code2, image, block_size)
    assert sim2.procs[0][0].is_powerdown() == False
    sim2.run_kernel()
    assert sim2.procs[0][0].is_powerdown() == False 
	def run_test(codegen_function, image, cascade, block_size):
		print 'running %s'%codegen_function.__name__
		print 'XXX histogram equalisation is not implemented yet, use violajones impl'
		print '    before executing simulator'
		image = reference.equalizeHist(image)

		width, height = block_size
		pe_dim = (len(image[0])//width, len(image)//height)

		args = {'haar_classifier': cascade, 'pe_dim':pe_dim}
		# now execute the codegen
		code = Code()
		code.set_generator(optimiser_wrapper(codegen_function), block_size, args)

		sim = Interpreter(code, image, block_size, 4)
		sim.run()

		detections_pixmap = sim.gen_output_image(1) # result is saved in first buffer

		# convert the number of rejections in the stages to detections
		detections = gen_code.convert_pixelmap_to_detections(detections_pixmap, cascade.size)
		return detections
	def run_test(position, integral_test, sq_integral_test, haar_size, block_size):
		integral_ptr = 0
		sq_integral_ptr = block_size[0]*block_size[1]

		code = Code()
		out_reg = code.alloc_reg()
		def code_gen(code, block_size, args):
			return gen_code.gen_calc_variance(code, out_reg, position, integral_ptr, sq_integral_ptr, haar_size, block_size)
		code.set_generator(optimiser_wrapper(code_gen), block_size)

		sim = Interpreter(code, integral_test, block_size)
		# hack: in order to avoid calculating integral images, inject random values into the sq_integral buffer
		# this is easy since their is only a single PE
		for i, row in enumerate(sq_integral_test):
			for j, v in enumerate(row):
				sim.procs[0][0].memory.set(sq_integral_ptr + len(row)*i+j, v)

		sim.run()

		pe = sim.procs[0][0]
		# extract value
		return (1./(pe.get_reg_by_name(str(out_reg)))), pe
def run_codegen_function(test_image, code_gen, block_size, args, buffer_sel = 1, **kwargs):
	image2buffer = kwargs['image2buffer'] if 'image2buffer' in kwargs else {}

	im_size = len(test_image[0]), len(test_image)
	pe_dim = [s//b for s,b in zip(im_size, block_size)]
	# fill this in for all functions
	args['pe_dim'] = pe_dim

	code = Code()
	code.set_generator(code_gen, block_size, args)

	sim = Interpreter(code, test_image, block_size)
	for buffer_nr, image in image2buffer.iteritems():
		sim.set_src_image(image, buffer_nr)

	sim.run()

	return sim.gen_output_image(buffer_sel, False, False, True), sim
Exemple #19
0
	def step(self, instr):
		for a in self.analysis:
			a.process(instr)
		Interpreter.step(self, instr)
Exemple #20
0
	def __init__(self, code, image, block_size, pe_nr_buffer = 4, pe_nr_reg = NR_REG):
		Interpreter.__init__(self, code, image, block_size, pe_nr_buffer, pe_nr_reg)
		self.analysis = []