ALOCAÇÃO, PARTICIONAMENTO H ARDWARE /S OFTWARE E ESCALONAMENTO

Dada uma biblioteca de componentes de sistema, tais como processadores, memórias e módulos IP (Intellectual Property) de terceiros, a tarefa de alocação é definida como a seleção do tipo e número destes componentes, assim como a determinação de sua interconexão, de tal forma que possam a funcionalidade do sistema ser implementada, as restrições de projeto ser satisfeitas e a função objetivo de custo ser minimizada [32]. Geralmente, esta tarefa é feita manualmente.

A tarefa de particionamento hardware/software tem por objetivo encontrar uma implementação que atenda os requisitos de desempenho a um custo mínimo. A idéia é explorar a potencialidade oferecida por componentes de hardware e de software. Geralmente, seções críticas do sistema em relação a tempo são associadas a implementações em componentes mais velozes (hardware dedicado), enquanto seções menos críticas (ou que exijam programabilidade) são associadas a software (executado por componentes geralmente mais lentos e baratos) [33].

Dado um conjunto de comportamentos e um possível conjunto de restrições de desempenho, a tarefa de escalonamento é determinar a ordem total dos tempos de chamada (para execução) das tarefas rodando num mesmo PE (Processor Element – Elemento Processador), ao mesmo tempo respeitando a ordem parcial imposta pelas dependências na funcionalidade, assim como minimizando o overhead (custo advindo) de sincronização entre os PEs e o overhead de troca de contexto dentro de cada PE [32].

As metodologias de coprojeto hardware/software diferem na ordem de execução destas etapas. Há metodologias que agrupam as tarefas de escalonamento e alocação numa única etapa, enquanto outras agrupam as tarefas de particionamento e alocação. Nesta seção, são vistos dois algoritmos. O primeiro deles é utilizado na metodologia Ptolemy, resultando no particionamento e escalonamento de tarefas de um sistema cujos componentes foram previamente alocados. O segundo algoritmo trata do chamado particionamento temporal, isto é, dado um particionamento espacial (ou comum, como explicado mais adiante) e uma alocação de componentes, o algoritmo faz o escalonamento das tarefas da aplicação, adotando técnicas de pipeline para explorar a concorrência entre estas, além de mapear as tarefas entre os componentes alocados.

O algoritmo de particionamento e escalonamento GCLP (Global Criticality/Local

Phase – Criticalidade Global/Fase Local) foi proposto por Kalavade e Lee [34] para uso na

metodologia Ptolemy. Seu aspecto chave é o mecanismo adaptativo das funções objetivo de custo, o qual é baseado na combinação entre medidas globais e locais. Como a minimização da área de hardware e as restrições de latência apresentam objetivos contraditórios, uma medida de criticalidade global (GC) do tempo é responsável pela seleção de uma função objetivo (dentre duas possíveis), de acordo com o tempo restante para execução da aplicação. Adicionalmente, características locais dos nós (nós = tarefas) são enfatizadas ao classificá-los em tipos fase local (LP). Um nó de fase local 1 (denominado extremista) é aquele que tem uma preferência óbvia por uma implementação em hardware ou em software. Um nó de fase local 2 (repelente) se opõe à implementação em hardware ou em software, quando comparado a outros nós. A cada iteração do algoritmo, os critérios globais e locais são relacionados por um mecanismo de threshold (limiar), de forma a determinar a melhor implementação (hardware ou software) para o nó em análise.

O modelo utilizado no algoritmo GCLP é um grafo orientado acíclico (DAG, Direct

Acyclical Graph), representando a aplicação. Os nós do grafo representam computações (no

nível de granulosidade de tarefas ou de processos), enquanto os arcos representam comunicação entre estas computações. A arquitetura corresponde a um processador genérico (para rodar os nós associados a software), um core-based ASIC (para implementar os nós associados a hardware) e uma memória (para armazenar o software e, quando for o caso, suportar comunicação via E/S mapeada para a memória). Assim, para que o algoritmo possa avaliar as alternativas de associação de nós à implementação em hardware ou em

software, cada nó i possui 4 atributos, quais sejam:

• ahi = área exigida para implementação do i-ésimo nó em hardware;

• asi = tamanho do código exigido para implementação do i-ésimo nó em software;

• thi = tempo de execução para implementação do i-ésimo nó em hardware;

• tsi = tempo de execução para implementação do i-ésimo nó em software.

Para cada arco ligando um nó i a um nó j, associa-se um número inteiro não negativo Nij indicando o número de amostras (samples) de dados enviadas de i para j. Os custos

associados à comunicação de uma amostra de dados através da interface hardware/software são fornecidos através dos números não negativos ahcomm (área de hardware), ascomm (área de

software) e tcomm (tempo de comunicação).

As restrições que devem ser atendidas pelo algoritmo GCLP são: • T = latência (tempo total disponível para execução da aplicação); • AH = capacidade do recurso de hardware (área máxima para o ASIC); • AS = capacidade do recurso de software (memória disponível).

Os resultados gerados pelo algoritmo são:

• Mapeamento dos nós: indicando implementação em hardware ou software para cada nó; • Escalonamento dos nós: indicando o tempo inicial de execução para cada nó.

Os resultados do algoritmo GCLP devem atender às restrições do projeto, levando em conta os custos de comunicação, de forma que a área ocupada pelos nós mapeados para

hardware seja mínima.

Cada iteração do algoritmo trata do mapeamento e escalonamento de um nó, de acordo com os valores GC, LP e threshold. Os valores GC e threshold são calculados a cada iteração; o valor LP é calculado previamente.

O cálculo da medida GC (Global Criticality) tem por finalidade indicar quão crítico o tempo restante para execução da aplicação está para os nós que ainda não foram escalonados. O valor de GC indica a probabilidade do nó a ser escalonado ser mapeado para hardware. Isto significa que, quanto maior for GC, mais restrito é o tempo para término de execução da aplicação, indicando que o nó em foco deve ser preferencialmente mapeado para

hardware, o que dependerá da comparação com o valor threshold.

Em cada etapa do algoritmo, o threshold (th) é inicializado em 0,5. Este valor pode ser alterado, caso o algoritmo adote características locais dos nós (chamadas de fase local), quantificadas por um valor ∆. Este valor ∆ é somado ao threshold, aumentando (caso ∆ seja positivo) ou diminuindo (caso ∆ seja negativo) seu valor inicial (0,5). Desta forma, o novo valor do threshold (th’) procurará favorecer a implementação do nó ou em hardware ou em

Caso 1: ∆ < 0

Neste caso, th’ < 0,5, indicando que as características locais do nó favorecem a sua implementação em hardware. Para que isto ocorra, a probabilidade do nó ser mapeado para

hardware (GC) deve ser maior do que th’, para que a função objetivo escolhida seja a de

minimizar o tempo final, o que favorecerá a escolha pela implementação em hardware. Isto é, a implementação em hardware é favorecida ao diminuir-se o valor inicial do threshold;

Caso 2: ∆ > 0

Neste caso, th’ > 0,5, indicando que as características locais do nó favorecem a sua implementação em software. Para que isto ocorra, a probabilidade do nó ser mapeado para

hardware (GC) deve ser menor do que th’, para que a função objetivo escolhida seja a de

minimizar a área em hardware, o que favorecerá a escolha pela implementação em

software. Isto é, a implementação em software é favorecida ao elevar-se o valor inicial do threshold.

Caso 3: ∆ = 0

Este caso ocorre quando o nó não é nem um extremista e nem um repelente, sendo classificado como nó normal (fase local 3). Desta forma, a probabilidade do nó ser mapeado para hardware (GC) é o valor que determina a escolha da função objetivo, a qual poderá ou minimizar o tempo final (mapeamento para hardware) ou minimizar a área em hardware (mapeamento para software).

As características dos módulos do sistema são incorporadas ao algoritmo GCLP nas etapas denominadas fase local (LP, Local Phase). As características levadas em conta dizem respeito a otimizações locais (nós extremistas) e a preferências relativas (nós repelentes). Um nó é extremista em hardware se ele consome muita área em hardware e pouco tempo de execução em software. Inversamente, um nó é extremista em software se ele consome muito tempo de execução em software e pouca área em hardware. Desta forma, um nó extremista em software reduzirá o valor do threshold, sinalizando uma maior possibilidade do nó vir a ser mapeado para hardware, dependendo do valor GC e da função objetivo. Já um nó extremista em hardware, aumentará o valor do threshold, indicando maior possibilidade de vir a ser mapeado para software, dependendo do valor GC e da função objetivo.

A repelência de nós é uma medida de comparação entre nós similares, que não sejam extremistas. Esta medida serve para indicar qual entre dois nós representaria um ganho maior caso fosse implementado em hardware (menor área de hardware) ou em software (menor tempo de execução). Esta comparação é feita com base no valor de repelência (RV) de cada nó. O valor de repelência de um nó i (RVi) é computado a partir de uma combinação

de valores atribuídos a propriedades de repelência para hardware e para software, em relação ao nó; estas propriedades estão relacionadas ao subgrafo, em nível de instruções, representante da tarefa associada ao nó i. Por exemplo, a porcentagem de instruções em nível de bit e o nível de precisão de instruções, são propriedades de repelência para uma implementação em software; já a porcentagem de instruções lookup-table e a porcentagem de instruções intensivas de memória, são exemplos de propriedades de repelência em hardware.

Detalhes do algoritmo GCLP não serão dados aqui. Pelo exposto em [34], o algoritmo parece bem completo, uma vez que leva em consideração tanto características locais quanto características globais das tarefas (nós) que compõem um sistema. Um dos pontos altos do algoritmo é o de qualificar o que é denominado como "experiência do projetista" na escolha de implementação de tarefas nitidamente direcionadas para hardware ou para

software (nós extremistas); outro ponto alto é a quantificação de tarefas com características

de implementação muito próximas, através do cálculo do RV para nós repelentes, o que possibilita comparar tarefas quanto ao ganho (em área de hardware ou em tempo de execução de software) que um determinado tipo de implementação produzirá. Em relação às características globais, o algoritmo automatiza a preocupação que um projetista deve ter quanto ao tempo final para encerramento da aplicação.

Outro algoritmo de particionamento é proposto por Bakshi e Gajski [33], o qual visa auxiliar no projeto de sistemas de processamento digital de sinais (DSP), tais como sistemas para processamento de imagens (decodificadores, compactadores). Este algoritmo deverá, dada uma especificação particionada hardware/software (particionamento espacial) e uma alocação de processadores (número e tipos), realizar as seguintes tarefas:

• Mapear cada um dos comportamentos (ou tarefas) de software nos processadores alocados;

• Criar estágios de pipeline e mapear cada comportamento a um destes estágios, de forma a explorar a concorrência entre os comportamentos;

• Escalonar os comportamentos em cada estágio de pipeline, entre os componentes de

hardware e os processadores alocados, de forma a satisfazer uma restrição de throughput

(taxa de processamento) a um custo mínimo de hardware.

Este conjunto de tarefas realizado pelo algoritmo denomina-se particionamento temporal. Inicialmente, vejamos a diferença entre particionamento espacial e temporal.

O particionamento espacial refere-se ao particionamento conforme é tratado na maioria das metodologias de projeto em nível de sistema, isto é, trata-se da associação do tipo de implementação (hardware ou software) para cada tarefa (conforme a granulosidade adotada) do sistema. Nesta associação, tarefas críticas são mapeadas para hardware, enquanto tarefas menos críticas (ou que exijam programabilidade) são mapeadas para componentes mais baratos ou mais lentos (geralmente, processadores de propósito geral, para rodar tarefas associadas a software).

O particionamento temporal, por sua vez, refere-se à exploração de concorrência entre as tarefas, de forma a atender uma dada restrição de taxa de processamento (throughput). Esta exploração de concorrência se dá através da execução de tarefas em estágios de pipeline distintos, isto é, busca-se analisar quais os ganhos obtidos (em termos de tempo) ao executar-se determinadas tarefas em paralelo, distribuindo-as em diferentes estágios de pipeline. Desta forma, o resultado do particionamento temporal é o escalonamento das tarefas (determinação do tempo inicial e final de execução de cada tarefa), além da associação (mapeamento) das tarefas de software aos processadores que as executarão. Assim, o particionamento temporal fornece informações bem mais completas do que o particionamento espacial, o qual fornece somente o tipo de implementação para cada tarefa (tipo software ou tipo hardware).

O grande diferencial do algoritmo de particionamento proposto por Bakshi e Gajski, está na exploração do pipeline em nível de sistema, necessário quando o pipeline em nível de registradores não é suficiente para atender as restrições de throughput.

O pipeline em nível de registrador procura explorar a concorrência entre os subcomponentes que compõem um componente de hardware dedicado. Esta exploração envolve a criação de estágios pipeline em vários níveis, tais como, pipeline em nível de instrução, pipeline em nível funcional (por exemplo, na ULA), entre outros. O pipeline em nível de registrador é capaz de gerar hardware dedicado com tempo de execução rápido; entretanto, um sistema formado por componentes otimizados de hardware dedicado (cada qual associado a uma tarefa) pode não ser capaz de atender as restrições de throughput. Neste ponto, a exploração de paralelismo na execução destas tarefas (e também das tarefas associadas a software) pode levar ao atendimento do trhoughput. Esta exploração é denominada de pipeline em nível de sistema, o qual busca a criação de estágios de execução concorrente (estágios de pipeline) envolvendo as tarefas do sistema.

As informações de entrada do algoritmo de particionamento temporal de Bakshi e Gajski são:

• Um grafo de fluxo de controle CFG(V,E), seção 2.2.2, descrevendo o particionamento espacial da especificação da aplicação. Seus nós representam tarefas, cada qual associada a um tipo de implementação (ou hardware ou software). As arestas do grafo representam dependências de controle entre tarefas;

• Uma alocação de processadores P selecionada de uma biblioteca de processadores. Esta alocação é formada pela quantidade e tipos de processadores necessários para executar as tarefas associadas a software;

• Um tempo de execução Tv para cada nó vh associado a hardware (vh ∈ V);

• Um tempo de execução Tvp para cada nó vs associado a software (vs ∈ V), para cada

processador selecionado p (p ∈ P);

• A restrição de throughput (taxa de processamento) T. As informações geradas pelo algoritmo são:

• O escalonamento e estágio pipeline de cada nó v, representados através dos pares (xv , yv)

e (x’v , yv), v ∈ V, tal que x’v > xv. Os valores xv e x’v representam o tempo de início e de

término de execução da tarefa v (este intervalo de tempo é denominado time-slot), enquanto o valor yv representa o número do estágio pipeline;

• A associação de um processador p (p ∈ P) para cada nó vs do tipo software (vs∈ V), tal

que p executará vs;

• uma lista de utilização para cada processador p ∈ P, formada por pares (xp1, xp2),

indicando os intervalos de tempo nos quais o processador é utilizado.

A associação de comportamentos (tarefas) aos estágios de pipeline deve ser feita de forma a atender 2 condições:

• Satisfazer a restrição de throughput T usando a alocação de processadores P; e

• Reduzir o número de estágios de pipeline (para reduzir a latência do projeto e a memória exigida para armazenar dados intermediários entre os estágios de pipeline).

A seguir, são dadas as etapas do algoritmo de particionamento temporal:

1. Para cada nó em CFG, determine o tempo de término mais longo entre o nó selecionado e