#! /usr/bin/env python
#
# Copyright (C) 2014 Intel Corporation
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
# Authors:
# Jason Ekstrand (jason@jlekstrand.net)
import itertools
import struct
import sys
import mako.template
import re
# Represents a set of variables, each with a unique id
class VarSet(object):
def __init__(self):
self.names = {}
self.ids = itertools.count()
self.immutable = False;
def __getitem__(self, name):
if name not in self.names:
assert not self.immutable, "Unknown replacement variable: " + name
self.names[name] = self.ids.next()
return self.names[name]
def lock(self):
self.immutable = True
class Value(object):
@staticmethod
def create(val, name_base, varset):
if isinstance(val, tuple):
return Expression(val, name_base, varset)
elif isinstance(val, Expression):
return val
elif isinstance(val, (str, unicode)):
return Variable(val, name_base, varset)
elif isinstance(val, (bool, int, long, float)):
return Constant(val, name_base)
__template = mako.template.Template("""
static const ${val.c_type} ${val.name} = {
{ ${val.type_enum} },
% if isinstance(val, Constant):
{ ${hex(val)} /* ${val.value} */ },
% elif isinstance(val, Variable):
${val.index}, /* ${val.var_name} */
${'true' if val.is_constant else 'false'},
nir_type_${ val.required_type or 'invalid' },
% elif isinstance(val, Expression):
nir_op_${val.opcode},
{ ${', '.join(src.c_ptr for src in val.sources)} },
% endif
};""")
def __init__(self, name, type_str):
self.name = name
self.type_str = type_str
@property
def type_enum(self):
return "nir_search_value_" + self.type_str
@property
def c_type(self):
return "nir_search_" + self.type_str
@property
def c_ptr(self):
return "&{0}.value".format(self.name)
def render(self):
return self.__template.render(val=self,
Constant=Constant,
Variable=Variable,
Expression=Expression)
class Constant(Value):
def __init__(self, val, name):
Value.__init__(self, name, "constant")
self.value = val
def __hex__(self):
# Even if it's an integer, we still need to unpack as an unsigned
# int. This is because, without C99, we can only assign to the first
# element of a union in an initializer.
if isinstance(self.value, (bool)):
return 'NIR_TRUE' if self.value else 'NIR_FALSE'
if isinstance(self.value, (int, long)):
return hex(struct.unpack('I', struct.pack('i', self.value))[0])
elif isinstance(self.value, float):
return hex(struct.unpack('I', struct.pack('f', self.value))[0])
else:
assert False
_var_name_re = re.compile(r"(?P<const>#)?(?P<name>\w+)(?:@(?P<type>\w+))?")
class Variable(Value):
def __init__(self, val, name, varset):
Value.__init__(self, name, "variable")
m = _var_name_re.match(val)
assert m and m.group('name') is not None
self.var_name = m.group('name')
self.is_constant = m.group('const') is not None
self.required_type = m.group('type')
if self.required_type is not None:
assert self.required_type in ('float', 'bool', 'int', 'unsigned')
self.index = varset[self.var_name]
class Expression(Value):
def __init__(self, expr, name_base, varset):
Value.__init__(self, name_base, "expression")
assert isinstance(expr, tuple)
self.opcode = expr[0]
self.sources = [ Value.create(src, "{0}_{1}".format(name_base, i), varset)
for (i, src) in enumerate(expr[1:]) ]
def render(self):
srcs = "\n".join(src.render() for src in self.sources)
return srcs + super(Expression, self).render()
_optimization_ids = itertools.count()
condition_list = ['true']
class SearchAndReplace(object):
def __init__(self, transform):
self.id = _optimization_ids.next()
search = transform[0]
replace = transform[1]
if len(transform) > 2:
self.condition = transform[2]
else:
self.condition = 'true'
if self.condition not in condition_list:
condition_list.append(self.condition)
self.condition_index = condition_list.index(self.condition)
varset = VarSet()
if isinstance(search, Expression):
self.search = search
else:
self.search = Expression(search, "search{0}".format(self.id), varset)
varset.lock()
if isinstance(replace, Value):
self.replace = replace
else:
self.replace = Value.create(replace, "replace{0}".format(self.id), varset)
_algebraic_pass_template = mako.template.Template("""
#include "nir.h"
#include "nir_search.h"
#ifndef NIR_OPT_ALGEBRAIC_STRUCT_DEFS
#define NIR_OPT_ALGEBRAIC_STRUCT_DEFS
struct transform {
const nir_search_expression *search;
const nir_search_value *replace;
unsigned condition_offset;
};
struct opt_state {
void *mem_ctx;
bool progress;
const bool *condition_flags;
};
#endif
% for (opcode, xform_list) in xform_dict.iteritems():
% for xform in xform_list:
${xform.search.render()}
${xform.replace.render()}
% endfor
static const struct transform ${pass_name}_${opcode}_xforms[] = {
% for xform in xform_list:
{ &${xform.search.name}, ${xform.replace.c_ptr}, ${xform.condition_index} },
% endfor
};
% endfor
static bool
${pass_name}_block(nir_block *block, void *void_state)
{
struct opt_state *state = void_state;
nir_foreach_instr_safe(block, instr) {
if (instr->type != nir_instr_type_alu)
continue;
nir_alu_instr *alu = nir_instr_as_alu(instr);
if (!alu->dest.dest.is_ssa)
continue;
switch (alu->op) {
% for opcode in xform_dict.keys():
case nir_op_${opcode}:
for (unsigned i = 0; i < ARRAY_SIZE(${pass_name}_${opcode}_xforms); i++) {
const struct transform *xform = &${pass_name}_${opcode}_xforms[i];
if (state->condition_flags[xform->condition_offset] &&
nir_replace_instr(alu, xform->search, xform->replace,
state->mem_ctx)) {
state->progress = true;
break;
}
}
break;
% endfor
default:
break;
}
}
return true;
}
static bool
${pass_name}_impl(nir_function_impl *impl, const bool *condition_flags)
{
struct opt_state state;
state.mem_ctx = ralloc_parent(impl);
state.progress = false;
state.condition_flags = condition_flags;
nir_foreach_block(impl, ${pass_name}_block, &state);
if (state.progress)
nir_metadata_preserve(impl, nir_metadata_block_index |
nir_metadata_dominance);
return state.progress;
}
bool
${pass_name}(nir_shader *shader)
{
bool progress = false;
bool condition_flags[${len(condition_list)}];
const nir_shader_compiler_options *options = shader->options;
% for index, condition in enumerate(condition_list):
condition_flags[${index}] = ${condition};
% endfor
nir_foreach_overload(shader, overload) {
if (overload->impl)
progress |= ${pass_name}_impl(overload->impl, condition_flags);
}
return progress;
}
""")
class AlgebraicPass(object):
def __init__(self, pass_name, transforms):
self.xform_dict = {}
self.pass_name = pass_name
for xform in transforms:
if not isinstance(xform, SearchAndReplace):
xform = SearchAndReplace(xform)
if xform.search.opcode not in self.xform_dict:
self.xform_dict[xform.search.opcode] = []
self.xform_dict[xform.search.opcode].append(xform)
def render(self):
return _algebraic_pass_template.render(pass_name=self.pass_name,
xform_dict=self.xform_dict,
condition_list=condition_list)