SMART O SMART é um serviço usado para caracterizar o comportamento do desempenho de aplicações baseadas em componentes. O serviço é implementado por um componente SCS denominado Reasoner, o qual deve ser instanciado em cada nó onde um componente de aplicação executa. Cada nó é analisado separadamente dos outros nós. A máquina de inferência do SMART analisa uma coleção de dados coletados pela infraestrutura de monitoramento do SCS e periodicamente: i) constrói um modelo de comportamento do desempenho da aplicação; ii) estima, com certa robustez, o estado de uma aplicação; e iii) se necessário, faz o diagnóstico da causa de um problema de desempenho. Atualmente, o componente Reasoner oferece as seguintes facetas: CPUPredictor: faceta que caracteriza o desempenho de uma aplicação usando como métrica o consumo de CPU exclusivamente. Reasoner: faceta que caracteriza o desempenho de uma aplicação pelo uso de um classificador probabilístico. Esse classificador é capaz de correlacionar valores de múltiplas variáveis observáveis em um estado do sistema. O estado do sistema é uma variável binária que pode assumir os seguintes valores: conformidade com um objetivo de desempenho ou violação do objetivo desejado. O objetivo do sistema é definido através de um limiar (SLO) estabelecido sobre uma das variáveis observáveis. Trainer: faceta usada para gravar logs da aplicação em execução. Os logs contêm os valores observados para o conjunto de variáveis monitoradas durante a execução da aplicação. ReasoningManager: faceta usada para configurar o componente Reasoner. Além das facetas descritas acima, o componente Reasoner possui também um receptáculo, o qual é usado para conectar o componente a um serviço de monitoramento. As interfaces implementadas pelas facetas do componente são ilustradas abaixo. enum SystemStatus{DEGRADATION,COMPLIANCE exception DiagnosisIsNotAvailable{ exception TrainingFailure{ exception ReasoningFailure{ exception CPUPredictionFailure{ struct ClassifierDescription { string name; sequence<string> options; string ranker; struct Scheme_str { string metricname; long numberofbins; boolean classvariable; boolean slobased; boolean rankable; long metricindex;
struct Instance_str { long metricindex; double metricvalue; typedef sequence<scheme_str> SchemeSeq; typedef sequence<instance_str>instanceseq; struct ClassificationResult { SystemStatus status; double degradationprobability; SchemeSeq culprit; interface Filter { InstanceSeq filtermetrics(in scs::instrumentation::machinestats stats); SchemeSeq getmetricdescriptions(); interface CPUPredictor { void startcpuprediction() raises (CPUPredictionFailure); void stopcpuprediction(); double getcpuprediction(); interface Reasoner{ void startreasoning() raises (ReasoningFailure); void stopreasoning(); ClassificationResult classifysystemstate(); interface Trainer{ void starttraining() raises (TrainingFailure); void stoptraining(); interface ReasoningManager { scs::instrumentation::statscollection getmediator(); ClassifierDescription getclassifierdescription(); long long getpollinginterval(); string getmachinename(); Filter getfilter(); string gettrainingfilename(); long getslovariable(); double getslovalue();
1-Representação de Métricas A máquina de inferência do SMART necessita de metadados sobre as métricas monitoradas. Esses metadados são usados para manter informações sobre as variáveis observáveis e são essenciais para o processamento e análise dos dados coletados. Para descrever uma métrica no SMART, usamos a estrutura Scheme_str. Os seguintes campos compõem essa estrutura: metricname: campo que define o nome de uma variável observável ou métrica. numberofbins: número de intervalos de discretização para a métrica em questão. classvariable: booleano que indica se a métrica em questão é a variável de classe, ou seja, a variável a ser estimada. slobased: booleano que indica se a métrica em questão é a métrica na qual o SLO é definido. rankable: booleano que indica se a métrica em questão deve ser considerada num processo de diagnóstico de um problema de desempenho metricindex: índice da métrica num vetor de métricas coletadas em um tempo t. Uma sequência Scheme_str descreve o dataset ou conjunto de dados a ser analisado. Uma sequência Instance_str descreve uma instância desse dataset, ou seja, um vetor de valores coletados em um instante t, sendo cada valor uma observação de uma métrica observável naquele instante. A estrutura Instance_str é composta pelos seguintes campos: metricvalue: valor observado para a métrica em um instante t. metricindex: o índice correspondente ã métrica no esquema. 2- Interfaces 2.1 Interface CPUPredictor Define as operações implementadas para controlar o processo de predição de comportamento por CPU. startcpuprediction: inicia o processo de predição de desempenho por CPU. stopcpuprediction: finaliza o processo de predição de desempenho por CPU; getcpuprediction: retorna o valor previsto ou estimado de consumo de CPU. 2.2 Interface Trainer Define as operações implementadas pela faceta Trainer. starttraining: inicia o Componente Reasoner no modo de operação Treinamento. Nesse modo, o componente Reasoner grava as métricas coletadas em um log de execução. stoptraining: finaliza o modo de operação Treinamento. 2.3 Interface Reasoner Define as operações da faceta Reasoner. startreasoning: inicia o processo de predição de desempenho pela máquina de inferência do SMART ( classificador probabilístico). stopreasoning: finaliza o processo de predição de desempenho pela máquina de inferência do SMART. classifysystemstate: classifica o estado do sistema em relação ao SLO definido, segundo a máquina de inferência do SMART. O resultado da classificação é retornado na estrutura ClassificationResult, a qual é constituída pelos seguintes campos:
status: o estado do sistema segundo a máquina de inferência do SMART. degradationprobability: a probabilidade de violação calculada pela máquina de inferência. culprit: as métricas reponsáveis pela degradação de desempenho, ordenadas de forma ascendente pela responsabilidade. 2.4 Interface Filter Interface que faz a mediação entre o serviço de monitoramento e o serviço de análise do SMART. Dentre as operações de integração entre os dois serviços destacam-se: getmetricdescriptions: método que retorna o esquema que descreve o dataset analisado. Esse esquema deve ser definido pelo usuário do SMART. filtermetrics: operação que transforma um conjunto (bruto) de métricas coletadas pelo serviço de monitoramento em uma instância do dataset defindo pelo usuário. 2.5 Interface ReasoningManager Define operações que podem ser invocadas para obter informações sobre a configuração do componente Reasoner. getmediator: retorna o componente mediador que está conectado ao componente Reasoner getclassifierdescription: retorna dados sobre o classificador o nome da classe que o implementa, os argumentos ou opções passados para o construtor da classe e o nome da classe que implementa o algoritmo de ranking. GetPollingInterval: retorna o intervalo de polling no qual o componente consulta o mediador para uma instância das métricas monitoradas getmachinename: retorna o IP da máquina onde o componente executa getfilter: retorna o objeto Filter definido pelo usuário gettrainingfilename: retorna o nome do arquivo de treinamento getslovariable: retorna a variável na qual se define o SLO getslovalue: retorna o percentil associado ao SLO 3-Instanciação Como todo componente SCS, o componente Reasoner é instanciado por uma fábrica (classe scs.reasonig.servant.reasonerfactory) que define as facetas e receptáculos do componente. Essa fábrica implementa o método create, que, por sua vez, é invocado pelo conmponente Container para criar uma instância do componente. Um dos argumentos do método create são os argumentos que são usados para configurar o componente que será instanciado. Para o componente Reasoner, os argumentos são: args[0] = o nome da classe que implementa o classificador (pode ser "") args[1] = intervalo de polling ao mediador (pode ser 0, assume-se o 15s) args[2] = o nome da classe que implementa a interface Filter args[3] = o nome do arquivo de treinamento args[4] = a lista de opções para o classificador (separadas por ;) args[5] = o nome do algoritmo de ranking args[6] = o percentil para o SLO 4-Análise dos dados O SMART pode analisar dados de forma online ou offline. Neste tutorial descrevemos as classes que implementam a análise offline.
Antes de proceder à análise dos dados gravados no arquivo de log, uma fase de preprocessamento prepara os dados. Esta fase é implementada pela classe scs.reasoning.servant.preprocessor que implementa os seguintes métodos createsourcefortraining: lê e agrupa em um único arquivo de dados arquivos de treinamento que estão sob um diretório raiz readfiletoarray: retorna o conteúdo do arquivo de log como um Array de números reais removeoutilier: elima possíveis outlier a partir de um certo percentil estimateclassvariable: calcula o valor da variável de classe para cada instância do arquivo de log normalize: normaliza os dados do dataset discretize: discretiza os dados do dataset writearraytofile: escreve o dataset (Array de números reais) para um arquivo. Finalizada a fase de preprocessamento, a análise dos dados é feita pela classe scs.reasoning.servant.processor. Esta é especializada nas classes scs.reasoning.servant.commandlineprocessor e scs.reasoning.servant.runtimeprocessor. A primeira implementa o treinamento offline do modelo, enquanto a segunda implementa usa o modelo construído para classificar uma instância em tempo de execução. Os métodos de cada uma dessas classes são descritos a seguir Processor: createscheme: cria o esquema do dataset a partir do esquema definido pelo usuário. ClassifyInstance: classifica um conjunto de dados CommandLineProcessor createinstances:cria as instâncias do dataset a partir do arquivo gerado pela classe Preprocessor. buildmodel: constrói o modelo de predição evaluatemodel: avalia o modelo construído savemodel: salva o modelo construído em um arquivo, de forma que ele possa ser lido em tempo de execução, pelo SMART. RuntimeProcessor loadmodel: carrega o modelo construído pela classe CommandLineProcessor. createinstances: cria uma instância a partir de um vetor de valores de métricas coletadas classifyinstances: classifica uma instância em tempo de execução evaluatemodel: avalia o modelo em tempo de execução getlabel: retorna o rótulo estimado ou previsto getdistributionprobability: retorna o vetor contendo as probabilidade estimas para cada rótulo da variável de classe. As interfaces CPUPredictor, Trainer, Reasoner e ReasoningManager são implementadas pelas classes scs.reasoning.servant.cpupredictorservant, scs.reasoning.servant.trainerservant,scs.reasoning.servant.reasonerse rvantoffline e scs.reasoning.servant.reasoningmanagerservant. 5- Estruturas de diretórios O SMART é implementado pelo pacotes scs.reasoning. Esse pacote possui os seguintes diretórios:
app: diretório onde se encontram aplicações de testes das classes do SMART. Uma aplicação importante é a classe CmdLineModelEvaluation que implementa um exemplo de como usar a classe CommandLineProcessor para treinar, construir e avaliar um modelo de predição. dataset: diretório onde são gravados os datasets usados pelo SMART. O diretório model guarda os modelos que serão lidos pela faceta Reasoner do Componente Reasoner. O diretório ranking guarda arquivos que são lidos pelo algoritmo de ranking. O diretório training guarda os arquivos de logs gerados pela faceta Trainer do Componente Reasoner. Exemplos de arquivos de log se encontram nesse diretório. servant: diretório que contem as classes que implementam o SMART.