triton/autotune/python/genetic.py

import random
import time
import sys
import tools
import pyviennacl as vcl
import numpy as np
import copy

from deap import algorithms
from deap import base
from deap import creator
from deap import tools as deap_tools

from collections import OrderedDict as odict


def closest_divisor(N, x):
    x_low=x_high=max(1,min(round(x),N))
    while N % x_low > 0 and x_low>0:
        x_low = x_low - 1
    while N % x_high > 0 and x_high < N:
        x_high = x_high + 1
    return x_low if x - x_low < x_high - x else x_high

def b_gray_to_bin(A='00000000', endian='big'):
    assert type(endian) is str
    assert endian == 'little' or endian == 'big'
    if endian == 'little': A = A[::-1] # Make sure endianness is big before conversion
    b = A[0]
    for i in range(1, len(A)): b += str( int(b[i-1] != A[i]) )
    if endian == 'little': b = b[::-1] # Convert back to little endian if necessary
    return b

class GeneticOperators(object):

    def __init__(self, device, statement, parameter_names, TemplateType, build_template, out):
        self.device = device
        self.statement = statement
        self.parameter_names = parameter_names
        self.TemplateType = TemplateType
        self.ParameterType = TemplateType.Parameters
        self.build_template = build_template
        self.cache = {}
        self.indpb = 0.05
        self.out = out

        creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
        creator.create("Individual", list, fitness=creator.FitnessMin)

        self.toolbox = base.Toolbox()
        self.toolbox.register("population", self.init)
        self.toolbox.register("evaluate", self.evaluate)
        self.toolbox.register("mate", deap_tools.cxTwoPoint)
        self.toolbox.register("mutate", self.mutate)
        self.toolbox.register("select", deap_tools.selNSGA2)

    @staticmethod
    def decode(s):
        FetchingPolicy = vcl.atidlas.FetchingPolicy
        fetch = [FetchingPolicy.FETCH_FROM_LOCAL, FetchingPolicy.FETCH_FROM_GLOBAL_CONTIGUOUS, FetchingPolicy.FETCH_FROM_GLOBAL_STRIDED]
        fetchA = fetch[s[0]]
        fetchB = fetch[s[1]]
        bincode = ''.join(s[2:])
        decode_element = lambda x:2**int(b_gray_to_bin(x), 2)
        simd = decode_element(bincode[0:3])
        ls0 = decode_element(bincode[2:5])
        ls1 = decode_element(bincode[5:8])
        kL = decode_element(bincode[8:11])
        mS = decode_element(bincode[11:14])
        kS = decode_element(bincode[14:17])
        nS = decode_element(bincode[17:20])
        if fetchA==FetchingPolicy.FETCH_FROM_LOCAL or fetchB==FetchingPolicy.FETCH_FROM_LOCAL:
            lf0 = decode_element(bincode[20:23])
            lf1 = ls0*ls1/lf0
        else:
            lf0, lf1 = 0, 0
        return [simd, ls0, kL, ls1, mS, kS, nS, fetchA, fetchB, lf0, lf1]

    def init(self, N):
        result = []
        fetchcount = [0, 0, 0]
        while len(result) < N:
            while True:
                fetch = random.randint(0,2)
                bincode = [fetch, fetch] + [str(random.randint(0,1)) for i in range(23)]
                parameters = self.decode(bincode)
                template = self.build_template(self.TemplateType.Parameters(*parameters))
                registers_usage = template.registers_usage(vcl.atidlas.StatementsTuple(self.statement))/4
                lmem_usage = template.lmem_usage(vcl.atidlas.StatementsTuple(self.statement))
                local_size = template.parameters.local_size_0*template.parameters.local_size_1
                occupancy_record = tools.OccupancyRecord(self.device, local_size, lmem_usage, registers_usage)
                if not tools.skip(template, self.statement, self.device):
                    fetchcount[fetch] = fetchcount[fetch] + 1
                    if max(fetchcount) - min(fetchcount) <= 1:
                        result.append(creator.Individual(bincode))
                        break
                    else:
                        fetchcount[fetch] = fetchcount[fetch] - 1
        return result

    def mutate(self, individual):
        while True:
            new_individual = copy.deepcopy(individual)
            for i in range(len(new_individual)):
                if i < 2 and random.random() < self.indpb:
                    while new_individual[i] == individual[i]:
                        new_individual[i] = random.randint(0, 2)
                elif i >= 2 and random.random() < self.indpb:
                    new_individual[i] = '1' if new_individual[i]=='0' else '0'
            parameters = self.decode(new_individual)
            template = self.build_template(self.TemplateType.Parameters(*parameters))
            #print tools.skip(template, self.statement, self.device), parameters
            if not tools.skip(template, self.statement, self.device):
                break
        return new_individual,

    def evaluate(self, individual):
        if tuple(individual) not in self.cache:
            parameters = self.decode(individual)
            template = self.build_template(self.TemplateType.Parameters(*parameters))
            try:
                tt = tools.benchmark(template, self.statement, self.device)
                self.out.write(','.join([str(tt)]+map(str,map(int,parameters)))+'\n')
                self.cache[tuple(individual)] = tt
            except:
                self.cache[tuple(individual)] = 10
        return self.cache[tuple(individual)],

    def optimize(self, maxtime, maxgen, compute_perf, perf_metric):
        hof = deap_tools.HallOfFame(1)
        # Begin the generational process
        gen = 0
        maxtime = time.strptime(maxtime, '%Mm%Ss')
        maxtime = maxtime.tm_min*60 + maxtime.tm_sec
        start_time = time.time()

        mu = 30
        cxpb = 0.2
        mutpb = 0.7

        population = self.init(mu)
        invalid_ind = [ind for ind in population if not ind.fitness.valid]
        fitnesses = self.toolbox.map(self.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit
        hof.update(population)

        while time.time() - start_time < maxtime:
            # Vary the population
            offspring = []
            for _ in xrange(mu):
                op_choice = random.random()
                if op_choice < cxpb:            # Apply crossover
                    ind1, ind2 = map(self.toolbox.clone, random.sample(population, 2))
                    ind1, ind2 = self.toolbox.mate(ind1, ind2)
                    del ind1.fitness.values
                    offspring.append(ind1)
                elif op_choice < cxpb + mutpb:  # Apply mutation
                    ind = self.toolbox.clone(random.choice(population))
                    ind, = self.toolbox.mutate(ind)
                    del ind.fitness.values
                    offspring.append(ind)
                else:                           # Apply reproduction
                    offspring.append(random.choice(population))

            #~ for x in offspring:
                    #~ print self.decode(x)
            # Evaluate the individuals with an invalid fitness
            invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
            fitnesses = self.toolbox.map(self.evaluate, invalid_ind)
            for ind, fit in zip(invalid_ind, fitnesses):
                ind.fitness.values = fit
            # Update the hall of fame with the generated individuals
            hof.update(offspring)
            # Select the next generation population
            population[:] = self.toolbox.select(population + offspring, mu)
            #Update
            gen = gen + 1
            best_profile = '(%s)'%','.join(map(str,GeneticOperators.decode(hof[0])));
            best_performance = compute_perf(hof[0].fitness.values[0])
            sys.stdout.write('Time %d | Best %d %s [ for %s ]\r'%(time.time() - start_time, best_performance, perf_metric, best_profile))
            sys.stdout.flush()
        sys.stdout.write('\n')
        return population