Você está na página 1de 49

1/45

Relatório Descritivo da Patente de Invenção para


“PAGINAÇÃO DE SISTEMA DE PROCESSAMENTO DE EVENTOS”
ANTECEDENTES DA INVENÇÃO
[001] Os sistemas de processamento de eventos
processam continuamente eventos em tempo real à medida que eles
são recebidos. Os eventos são itens de dados que incluem uma carga
útil de dados e um tempo associado. O processamento de eventos
opera com respeito a sequências de eventos ou fluxos de eventos
assíncronos, que são sequências de eventos que ocorrem ao longo do
tempo. Exemplos de sequências de eventos incluem letreiros digitais
da bolsa de valores identificando alterações nos preços de uma ação e
mensagens de mídias sociais. O processamento é especificado em
uma sequência de eventos com uma consulta para permitir projeção,
filtragem e agregação, por exemplo. Diferentemente das consultas
tradicionais a bancos de dados, as consultas de processamento de
eventos não são avaliadas uma vez em relação aos dados
armazenados. Em vez disso, as consultas de processamento de
eventos são avaliadas continuamente em relação a outros eventos à
medida que os eventos ocorrem. Para permitir o processamento
substancialmente em tempo real, os sistemas de processamento de
eventos armazenam consultas na memória e avaliam as consultas à
medida que os eventos chegam no sistema.
SUMÁRIO
[002] A seguir, será apresentado um sumário simplificado a
fim de oferecer uma explicação básica de alguns aspectos da matéria
revelada. Esse sumário não se trata de uma visão geral extensiva.
Não há a intenção de identificar elementos chave/cruciais ou de
delinear o âmbito da matéria reivindicada. Sua única finalidade é a de
apresentar alguns conceitos da invenção, de forma simplificada, para
2/45

servir de prelúdio à descrição mais detalhada apresentada mais


adiante.
[003] Descrita resumidamente, a presente revelação diz
respeito à paginação de sistema de processamento de eventos. É
gerada uma forma paginável de uma consulta de processamento de
eventos que suporta a permutação de uma consulta de processamento
de eventos para dentro e para fora da memória. Por exemplo, a
consulta de processamento de eventos pode ser reescrita para incluir
disparadores de entrada de página (page-in) e saída de página (page-
out), bem como funcionalidades para dar suporte ao carregamento
tardio e a preservação de uma consulta em uma saída de página. Em
operação, a consulta de processamento de eventos é carregada para
a memória após observar um disparador de entrada de página e
descarregada da memória para um armazenamento persistente após
observar o disparador de saída de página.
[004] Para a realização dos fins citados e relacionados,
certos aspectos ilustrativos da matéria reivindicada são descritos neste
documento em relação à descrição seguinte e aos desenhos anexos.
Esses aspectos indicam várias formas em que a matéria reivindicada
pode ser praticada, todas as quais devem estar dentro do âmbito da
matéria reivindicada. Outras vantagens e aspectos novos irão
transparecer na descrição detalhada seguinte, ao ser considerada em
combinação com os desenhos.
DESCRIÇÃO RESUMIDA DOS DESENHOS
[005] A FIG. 1 é um diagrama de blocos de um sistema de
processamento de eventos.
[006] A FIG. 2 é um diagrama de blocos de um componente
de paginação representativo.
[007] A FIG. 3 é um diagrama de blocos de um componente
de reescrita representativo.
3/45

[008] A FIG. 4 é uma ilustração gráfica de uma reescrita


com funções de coleta de estatísticas e paginação baseado nos dados
de histórico.
[009] A FIG. 5 é um diagrama de fluxo de dados de um
método para gerar uma consulta paginável em um sistema de
processamento de eventos.
[0010] A FIG. 6 é um diagrama de fluxo de dados de um
método de paginação de uma consulta.
[0011] A FIG. 7 é um diagrama de fluxo de dados de um
método de entrada de paginação de uma consulta.
[0012] A FIG. 8 é um diagrama de fluxo de dados de um
método de descarregamento de uma consulta da memória.
[0013] A Fig. 9 é um diagrama de blocos esquemático
ilustrando um ambiente operacional adequado para aspectos da
presente revelação.
DESCRIÇÃO DETALHADA
[0014] Um sistema de processamento de eventos pode
envolver a hospedagem e o oferecimento de grandes quantidades de
assinaturas ou consultas de eventos duradouras. Por exemplo, podem
existir muitas consultas para um único usuário, tais como as que são
associadas a notificações diárias de trânsito para o trabalho,
atualizações de informações do tempo, notícias sobre tópicos
favoritos, atualizações de pontuações de esportes e notificações de
voo de companhias aéreas, dentre outras coisas. Além disso, no
contexto de um sistema ou serviço de processamento de eventos em
grande escala, isto pode corresponder a milhões de consultas para
processamento, ou uma ordem de magnitude maior. O processamento
de eventos também pode envolver uma grande quantidade de eventos
além de uma grande quantidade de assinaturas.
4/45

[0015] Para alcançar o processamento quase em tempo real,


é necessário armazenar o máximo de código possível associado a
consultas de processamento de eventos na memória. Como resultado,
quando ocorre um evento, não ocorre retardo ao carregar o código na
memória para processar o evento.
[0016] No entanto, os sistemas de processamento de
eventos podem ter consultas fixas pequenas e não tão pequenas que
ocupam quantidades não-triviais de memória quando mantidas
residentes na memória. Em vista da finitude da memória e do
processamento em grande escala, o desafio está em como fazer a
permutação do código de processamento de eventos para a memória
e para fora da memória de maneira inteligente.
[0017] Os sistemas operacionais empregam uma técnica de
paginação para gerenciar a memória pela leitura e gravação de
páginas de dados no e a partir do armazenamento secundário, tal
como disco para uso, no armazenamento primário, tal como memória.
A paginação do sistema operacional, entretanto, é independente do
domínio, e assim, pode tomar decisões inferiores às ideais a respeito
de quanto e qual página será carregada e descarregada.
Adicionalmente, as técnicas de paginação relacionadas aos sistemas
operacionais de propósito geral não se dimensionam bem para o
processamento de eventos de alto volume e resultam em acessos
excessivos ao disco e à memória.
[0018] Os detalhes abaixo dizem respeito de forma geral à
paginação do sistema de processamento de eventos.
[0019] Consultas de processamento de eventos pagináveis
são geradas para dar suporte a consultas de permutação, ou partes
das mesmas, para dentro e para fora da memória. O suporte à
paginação pode ser oferecido pela reescrita de consultas de
processamento de eventos de acordo com uma concretização. Por
5/45

exemplo, as expressões de consulta podem ser automaticamente


reescritas com disparadores de entrada de página, disparadores de
saída de página, bem como funcionalidades para carregamento tardio
e preservação de consultas. Além disso, os disparadores podem ser
especificados com relação a sequências ou fluxos de eventos,
permitindo assim a exploração de características específicas ao
domínio de um sistema de processamento de eventos. Também pode
ser inserida funcionalidade para coletar dados relacionados à
execução da consulta. Subsequentemente, os dados coletados podem
ser analisados quanto a padrões úteis na especificação de
disparadores de entrada de página e saída de página. Adicionalmente,
a funcionalidade de paginação pode explorar aspectos de um sistema
de processamento de eventos, incluindo operadores de consulta
criação de pontos de verificação, por exemplo.
[0020] Os vários aspectos da presente revelação são agora
descritos em mais detalhes com referência aos desenhos em anexo,
em que números iguais referem-se a elementos iguais ou
correspondentes em todas as partes. Deve-se compreender,
entretanto, que os desenhos e a descrição detalhada relacionada a
eles não têm a intenção de limitar a matéria reivindicada à forma
específica revelada. Em vez disso, a intenção é de cobrir todas as
modificações, equivalentes e alternativas incluídas dentro do âmbito e
da essência da matéria reivindicada.
[0021] Referindo-se inicialmente à FIG. 1, o sistema de
processamento de eventos 100 é ilustrado. De acordo com um padrão
de design do observador, o sistema de processamento de eventos 100
é configurado para aceitar assinaturas de um ou mais observadores
para uma ou mais sequências de eventos observáveis, ou fluxos, e
fornecer notificações ao um ou mais observadores em linha com as
assinaturas correspondentes. As assinaturas podem corresponder a
6/45

ou incluir consultas fixas que executam continuamente dados de


processamento à medida que chegam pela duração da assinatura,
diferentemente das consultas ad hoc, que deverão ser executadas
apenas uma vez. O tipo de notificação pode variar desde simples
alertas a uma sequência de eventos que também podem aceitar
assinaturas.
[0022] O sistema de processamento de eventos 100 inclui o
componente de avaliação 110, o componente otimizador 120 e o
componente de paginação 130. O componente de avaliação 110 é
configurado para avaliar consultas de processamento de eventos ou,
de maneira mais simples, consultas. As consultas podem ser
especificadas em termos de expressões de consulta que incluem uma
pluralidade de operadores de consulta suportados pelo sistema de
processamento de eventos para realizar projeção, filtragem e
agregação, dentre outras coisas. As consultas podem ser carregadas
na memória e, quando do recebimento dos dados, o componente de
avaliação 110 pode avaliar as consultas em relação aos dados e
produzir notificações.
[0023] O componente otimizador 120 é configurado para
otimizar as consultas recebidas para melhorar o desempenho de
avaliação. O componente otimizador 120 pode explorar as
propriedades algébricas das consultas e dos dados com relação às
capacidades de processamento e carregamento de recursos do
sistema, dentre outras coisas, para gerar uma consulta modificada
para avaliação pelo componente de avaliação 110. Como exemplos
não-limitantes, o componente otimizador 120 pode coalescer uma
série de filtros em um único filtro, mover um filtro ou dividir uma
consulta para processamento simultâneo.
[0024] O componente de paginação 130 é configurado para
permutar as consultas para dentro e ara fora da memória. Mais
7/45

especificamente, o componente de paginação 130 é configurado para


carregar e descarregar o código e os dados associados a uma
consulta para dentro e para fora da memória. Aqui, o carregamento de
uma consulta para a memória é chamado de entrada de paginação de
uma consulta, e o descarregamento de uma consulta da memória é
chamado de saída de paginação de uma consulta. Embora se utilizem
aqui os termos entrada e saída de paginação, isso não significa
necessariamente que um bloco de armazenamento chamado de
página é carregado na memória ou descarregado da memória da
maneira que é feita convencionalmente por um sistema operacional.
Em vez disso, o bloco de armazenamento pode ter substancialmente
qualquer tamanho associado ao código de consulta e dados
específicos.
[0025] De acordo com uma concretização, o componente de
paginação 130 pode reutilizar os aspectos e a funcionalidade de um
sistema de processamento de eventos para realizar a paginação. Uma
abordagem consiste em construir a paginação em um mecanismo de
execução de consulta específico, ou no componente de avaliação 110
descrito aqui. Isto, entretanto, envolve produzir um sistema de
paginação de baixo nível com pouca abstração envolvendo
agendadores de tarefas, gerenciadores de memória e/ou
gerenciadores de entrada/saída, por exemplo. Uma segunda
abordagem, descrita aqui, consiste em construir sobre as capacidades
do processamento de eventos e implementar a paginação com
operadores de consulta. Como será descrito em mais detalhes abaixo,
uma expressão de consulta compreendendo um ou mais operadores
de consulta pode ser reescrita para incluir suporte à paginação.
Ademais, características específicas do domínio de alto nível de um
sistema de processamento de eventos, que não estão disponíveis aos
8/45

mecanismos de paginação de baixo nível do sistema operacional,


podem ser exploradas para a paginação.
[0026] Por exemplo, considere uma consulta de
acompanhamento de voo que notifica um indivíduo se o voo do
indivíduo sofrer algum atraso. Esta consulta poderia ser enviada após
a reserva de um voo, mas somente precisa estar ativa um dia antes da
partida do voo. Tal consulta fixa possui vida longa, possivelmente por
meses, entre o tempo em que a consulta é enviada e o tempo em que
a consulta está ativa. Uma vez que o código correspondendo à
consulta não irá reagir a quaisquer eventos por um período, o código
pode ser descarregado da memória e subsequentemente carregado
para a memória um dia antes da partida do voo. Este é um exemplo
bastante trivial, pois lida com o tempo explícito na consulta; contudo
neste exemplo, realça o uso do conhecimento do domínio da consulta
e do espaço de eventos para tomar decisões inteligentes relacionadas
a quando carregar e descarregar consultas da memória.
[0027] Voltando a atenção para a FIG. 2, um componente de
paginação representativo 130 é representado. O componente de
paginação 130 inclui o componente de reescrita 210, o
armazenamento de estatísticas 220, o componente de processamento
230 e o componente de atualização 240. O componente de reescrita
210 é configurado para reescrever expressões de consulta de uma
forma que adicione suporte à paginação. Em outras palavras, a
reescrita transforma as consultas em consultas pagináveis. A reescrita
pode disparar a paginação baseado na chegada de eventos em uma
sequência de eventos. Embora não e limite a isto, a paginação pode
ser disparada com base em uma sequência de eventos ou unidades
de contagem do temporizador. A reescrita também pode envolver a
adição de um mecanismo para disparar uma saída de página.
Reescritas adicionais podem estar relacionadas ao carregamento
9/45

tardio, bem como à coleta e utilização de dados de execução para


tomar decisões de paginação. Em particular, consultas ou partes das
mesmas podem ser injetadas com funcionalidade para coletar dados
relacionados à execução de consultas e salvar os dados no
armazenamento de estatísticas 220. Tais dados podem capturar o
número de eventos, bem como quando os eventos ocorrem, dentre
outras coisas. O componente de processamento 230 é configurado
para analisar e processar os dados para detectar padrões que podem
ser úteis para especificar uma consulta paginável. Por exemplo, se a
atividade de processamento de eventos ocorrer diariamente às 8 horas
da manhã (por exemplo, devido a um evento chegar em uma das
entradas da consulta), o componente de processamento 230 pode
detectar ou inferir este padrão. Como resultado, um disparador de
entrada de página poder ser diariamente antes das 8 da manhã, e um
disparador de saída de página em algum horário depois de 8 da
manhã. Quando tais dados ou informações relacionadas aos padrões
estão disponíveis para a consulta ou consultas similares, o
componente de reescrita 210 pode utilizar informações para iniciar a
reescrita de uma consulta em uma forma paginável. No entanto, o
componente de reescrita também pode especificar a consulta de uma
maneira que possibilite atualização subsequente. O componente de
atualização 240 é configurado para atualizar uma consulta paginável
baseado em padrões identificados pelo componente de
processamento 230. Em particular, os disparadores de entrada de
página e saída de página podem ser alterados para refletir o
conhecimento atual referente a uma consulta e aos eventos
relacionados.
[0028] Voltando a atenção brevemente para a FIG. 3, um
componente de reescrita 210 ilustrativo é ilustrado em detalhes
adicionais. Como ilustrado, o componente de reescrita 210 inclui o
10/45

componente de entrada de página 310, o componente de cálculo 320


e o componente de saída de página 330. O componente de entrada de
página 310 é configurado para injetar funcionalidade em uma
expressão de consulta para disparar uma funcionalidade de entrada de
página que carrega a memória com código e potencialmente dados de
estado associados à operação de consulta. A funcionalidade de
entrada de página pode ser disparada com base na ocorrência de um
evento, tal como um tique de relógio ou alguma outra mensagem.
Além disso, o componente de entrada de página 310 é configurado
para inserir funcionalidade que permite atualizar quando disparar uma
entrada de página, por exemplo, baseado nas estatísticas de
execução anteriores. O componente de cálculo 320 é configurado para
injetar funcionalidade que permite que pelo menos uma parte de uma
expressão de consulta ou cálculo associado com o mesmo seja
permutada para dentro e para fora da memória. Em uma
implementação, isto pode ser realizado utilizando a funcionalidade de
carregamento tardio de um sistema de processamento de eventos,
bem como persistência de estado do operador na forma de
funcionalidade de ponto de verificação. O componente de cálculo 320
também é configurado para injetar funcionalidade para coletar dados
relativos à execução e salvá-los no armazenamento de estatísticas
220. O componente de saída de página 330 é configurado para injetar
funcionalidade que dispara uma operação de saída de página. Isto
pode ser realizado pelo menos em parte explorando-se a
funcionalidade de ponto de verificação de um sistema de
processamento de eventos para salvar o código de consulta e o
estado em um armazenamento persistente e iniciar o
descarregamento do código da memória, por exemplo, estabelecendo
um ponteiro como nulo e permitindo que os espaços sejam retomados
por um mecanismo de “coleta de lixo”. Também pode ser adicionada
11/45

funcionalidade pelo componente de saída de página 320 para permitir


atualizações quanto a quando disparar uma operação de saída de
página, por exemplo, baseado em estatísticas de execução.
[0029] O que se seguem são detalhes associados a uma
implementação ilustrativa do aspecto da revelação. A descrição inicia
com a entrada de paginação de um código de consulta e dados com
temporizadores. Isto é seguido por uma descrição de padrões de
ativação para o código de entrada de página. Finalmente, uma
descrição da saída de paginação do código e dos dados é
apresentada.
[0030] Várias consultas fixas podem ser enviadas bastante
tempo antes de se tornarem ativas. Algumas dessas consultas podem
ter vida longa. Considere uma consulta de acompanhamento de voo.
Uma consulta fixa acompanhando um voo geralmente só precisa durar
vinte e quatro horas, iniciando algum tempo antes do check-in, por
exemplo, para sugerir partir para o aeroporto ou cancelar, e durar até
certo tempo após a aterrissagem, por exemplo, para sugerir pegar
alguém no aeroporto. No entanto, as consultas fixas para
acompanhamento de voo podem ser enviadas a um sistema de
processamento de eventos para processamento após a reserva de um
voo. Adicionalmente, pode haver uma consulta para várias pessoas
interessadas no mesmo voo.
[0031] Para descrever tais consultas, geralmente se utilizam
operadores baseados em tempo para programar temporalmente a
execução de uma consulta. Para o exemplo da consulta de voo, um
operador “DelaySubscription” ou “SkipUntil” pode ser usado para
retardar o processamento de eventos até que alguém antes do voo
parta e um operador “TakeUntil” pode ser usado para obter um efeito
similar em termos de descartar a consulta após o voo ter aterrissado.
Por exemplo:
12/45

flights.DelaySubscription(departure – 12 hr)
.Where(f => f.Id == "BA49")
.TakeUntil(landing + 12hr)
.Subscribe(...)
[0032] A expressão de consulta acima pode ser reescrita
para dar suporte à paginação baseado nas propriedades algébricas da
consulta. Primeiramente, o operador “DelaySubscription” pode
geralmente ser substituído por outros operadores de consulta (por
exemplo, algumas propriedades em torno da ausência de efeitos
colaterais devido a uma assinatura podem precisar ser mantidas). Em
outras palavras, a ordem do operador "DelaySubscription" não importa
em relação a outros operadores. Por conseguinte, o operador
“DelaySubscription” pode ser empurrado para baixo, para mais perto
do usuário. De fato, o operador pode ser movido logo à frente da
chamada “Subscribe”, como segue:

flights.Where(f => f.Id == "BA49")


.TakeUntil(landing + 12hr)
.DelaySubscription(departure – 12 hr)
.Subscribe(...)

[0033] Em seguida, o operador “DelaySubscription” pode ser


expandido para uma forma mais primitiva usando a identidade
algébrica a seguir:

xs.DelaySubscription(t) == Timer(t).SelectMany(_ => xs)

[0034] Aqui, a origem do operador “DelaySubscription”, “xs”,


termina no corpo lâmbda para a função seletora do operador
13/45

“SelectMany”. Neste ponto, a funcionalidade de ponto de verificação


associada a um sistema de processamento de eventos pode ser
empregada, especificamente criando um ponto de verificação para
operadores de ordem superior, tal como “SelectMany”. Não é até um
evento chegar a partir da origem do operador “SelectMany”, neste
caso, um pulso do temporizador, que o corpo da função seletora tem
de ser carregado na memória. O exemplo funcional pode ser escrito
como segue:

Timer(departure - 12hr).SelectMany(_ => flights.Where(f => f.Id ==


"BA49")
.TakeUntil(landing + 12hr))
.Subscribe(...)
[0035] A parte em itálico da consulta pode ser retirada da
consulta pela inserção de uma expressão de “interceptação”.
Utilizando a capacidade de definir um observável (o tipo da parte em
itálico) como um artefato nomeado, a porção de código pode ser
removida. Um novo artefato pode ser definido como se segue:

ctx.DefineObservable(someId, flights. Where(f => f.Id == "BA49")


.TakeUntil(landing + 12hr));

[0036] O artefato “someId” é um observável (por exemplo,


tipo IObservable) que não contém código, somente um identificador.
Este identificador pode ser usado como um substituto para a porção
removida da consulta, inserindo assim um nível de indireção. Isto
permite que a consulta original seja reescrita em sua forma final:

Timer(departure - 12hr).SelectMany(_ => someId)


.Subscribe(...)
14/45

[0037] Isto significa que a assinatura com uma consulta


específica é retardada até doze horas antes da partida. Neste ponto, o
operador “SelectMany” irá receber um evento e o código de consulta
será carregado na memória, por exemplo, pela leitura do código a
partir do disco, compilação do código e carregamento do código para a
memória. O resultado é que o código residente para a lógica de
consulta é reduzido significativamente. A forma final acima assume
que o componente de avaliação 110 não realiza o alinhamento
antecipado (eager) dos artefatos referidos na consulta, especialmente
se estes ocorrerem em posições internas (por exemplo, expressões
lâmbda), mas, em vez disso, realiza isto de forma tardia, postergando
o alinhamento até que necessário. Tal comportamento pode ser tanto
intrínseco ao sistema quanto adicionado ao componente de reescrita
210 como se segue:

Timer(departure - 12hr).SelectMany(_ => Defer(someId))


.Subscribe(...)

[0038] Em e de si próprio, o operador “SelectMany”


desacopla uma “origem” externa observável e assinaturas para um ou
mais observáveis “internos”. As porções internas podem ter seu ponto
de verificação criado separadamente da porção interna, e somente são
instanciadas após o recebimento de um evento a partir da assinatura
de origem externa, tal como a sequência do temporizador, neste
exemplo. Entretanto, isto pode ser adicionalmente otimizado pela
redução do padrão para um operador especial se isto se mostrar
benéfico em termos de utilização de recursos. Por exemplo, um
operador “ContinueWith” poderia ser empregado como se segue:
15/45

Timer(departure - 12hr).ContinueWith(someId)
.Subscribe(...)

[0039] Otimizações adicionais podem ser feitas explorando


propriedades do temporizador, por exemplo, coalescendo múltiplos
temporizadores em temporizadores mestres de alta granularidade que
podem ser usados para disparar a instanciação dos temporizadores no
nível seguinte. Isto pode ser benéfico pelo fato de que os objetos que
se referem ao recurso podem ser reutilizados, em vez de instanciar
múltiplos objetos de temporizador em diferentes consultas fixas. Esses
objetos podem ser coalescidos com um espaço de consumo da lista
de manipulador O(n). Considere as seguintes consultas:

Timer(tl).SelectMany(_ => xs.Bar().Foo()). Subscribe(...)


Timer(t2).SelectMany(_ => ys.Qux().Baz()).Subscribe(...)

[0040] Usando as técnicas descritas acima, porções internas


dos operadores “SelectMany” podem ser descarregadas da memória.
No entanto, os operadores “SelecyMany” residentes podem ser
adicionalmente otimizados por temporizadores coalescentes. A
reescrita algébrica para temporizadores é como se segue:

Timer(t) == Timer(N * (t / N)). SelectMany(_ => Timer(t % N))

[0041] Aqui, um temporizador com tempo devido “t” em um


temporizador de maior granularidade com uma resolução de “N”.
Empregando a eliminação de subexpressões comuns, é possível
agora coalescer recursos de tempo. Por exemplo, se "N” for definido
como vinte e quatro horas, não é até meia-noite do dia do tempo
devido que os temporizadores restantes são instanciados. Assim,
16/45

somente um temporizador de dia precisa estar residente por dia.


Supondo que os temporizadores "tl" e "t2", no exemplo, resultam no
mesmo dia “d”, então:

Timer(d). SelectMany(_ => Timer(tl % N))


.SelectMany(_ => xs.Bar().Foo()).Subscribe(...)

Timer(d).SelectMany(_ => Timer(t2 % N))


.SelectMany(_ => ys.Qux().Baz()).Subscribe(...)

[0042] Adicionalmente, os operadores SelectMany podem ser


virados “de dentro para fora” usando a seguinte identidade (se alguns
pré-requisitos a respeito dos efeitos colaterais se mantiverem):

xs.SelectMany(_ => ys).SelectMany(_ => zs)


==
xs.SelectMany(_ => ys.SelectMany(_ => zs))

[0043] Como resultado, os seguintes planos de consulta são


produzidos:

Timer(d).SelectMany(_ => Timer(tl % N)


.SelectMany(_ => xs.Bar().Foo()))
.Subscribe(...)

Timer(d).SelectMany(_ => Timer(t2 % N)


.SelectMany(_ => ys.Qux().Baz()))
.Subscribe(...)
17/45

[0044] Não apenas “Timer(d)” pode ser reutilizado, os corpos


dos operadores “SelectMany” podem ser descarregados da memória.
O componente de reescrita 210 também pode recursivamente
reaplicar esta técnica para obter o próximo nível de temporizador de
alta granularidade (por exemplo, com uma resolução M < N, tal como 1
hora). Observe que o esquema de paginação descrito acima possui o
benefício de buscar expressões requeridas à frente do tempo,
portanto, o custo da entrada de página não afeta adversamente a
precisão do temporizador. Este parâmetro pode ser ajustado, por
exemplo, com base em um parâmetro de tolerância de tempo passado
para a consulta. Por exemplo, poderia-se arredondar os
temporizadores para uma resolução de um minuto para impulsionar a
probabilidade de reutilização.
[0045] Embora a prorrogação baseada em temporizador do
carregamento de código possa ser utilizada com bastante frequência,
como descrito acima, a prorrogação baseada em temporizador do
código requer que as consultas tenham um certo formato. Entretanto,
as consultas podem ter um formato arbitrário. Por exemplo, alguma
sequência ou fluxo de eventos diferente do temporizador pode ser
utilizado como uma origem de consulta. Neste caso, somente a
reescrita algébrica pode não ser suficiente.
[0046] Em vez disso, as consultas podem ser reescritas com
código para coletar estatísticas relacionadas à execução da consulta,
que podem ser salvas no armazenamento de estatísticas 220. O
armazenamento de estatísticas 220 pode, dessa forma, salvar
estatísticas de histórico referentes à execução da consulta. O
componente de processamento 230 é configurado para operar com
relação a estatísticas de histórico e determinar e/ou inferir informações
úteis para paginação, tal como quando e com que frequência os
eventos ocorrem. O componente de reescrita 210 ou o componente de
18/45

atualização 240 pode empregar dados ou informações do componente


de processamento 230 na especificação de consultas para paginação,
a saber, disparadores de entrada de página e saída de página.
[0047] Considere uma origem que produz eventos com
pouca frequência. Aqui, o restante da consulta poderia ser carregado
tardiamente. De modo mais geral, as consultas podem ter muitas
origens, mas as técnicas descritas aqui são igualmente aplicáveis.
Consultas de origem única são consideradas por simplicidade. Por
exemplo, considere a expressão de consulta a seguir:

weather("SEA").Where(w => w.Temperature > 30C).Bar().Foo()

[0048] Embora o fluxo parametrizado para clima em Seattle


possa produzir eventos com frequência, as chances de um evento
passar pelo predicado (temperatura superior a 30 graus Celsius) são
bastante remotas. Tais informações podem ser obtidas por
instrumentação de consulta para obter estimativas de cardinalidade
(ou, em vez disso, velocidade, dada a importância da dimensão
temporal em um sistema de processamento de eventos) que possam
ser levadas em consideração ao se reescrever a consulta:

let xs = weather("SEA").Where(w => w.Temperature > 30C) in


xs.Measure().Bar().Foo()

[0049] Aqui, o operador "Measure” toma “xs” como a origem,


não apenas para subscrever-se para ela, mas também para associar
medições com esta subexpressão. Por exemplo, o operador “Measure”
pode armazenar registros de histórico do índice de eventos produzido
pela subexpressão. Se "weather("SEA")" estivesse para ser
instrumentado de uma maneira similar, a relação de ingresso e
19/45

egresso para a subexpressão também poderia ser calculada. Deve-se


apreciar que muitas estatísticas podem ser obtidas a partir disto, de
várias ordens de derivadas (contagem de evento, velocidade,
aceleração, taxa de variação de aceleração (jerk); tempo para
processar, etc.).
[0050] Observe que a parametrização do fluxo “weather”
também possibilita filtragem, mas as mesmas observações se
aplicariam se o fluxo fosse uma “mangueira de incêndio” massiva que
necessitasse de filtragem usando o operador “Where”:

weather. Where(w => w.City == "SEA" && w.Temperature >


30C).Bar().Foo()

[0051] Em tais casos, as consultas poderiam ser


normalizadas, por exemplo, com várias cláusulas de operador “Where”
consecutivas, para colocar o predicado mais restritivo primeiro. Para o
que se segue, suponha que a condição de temperatura cause o
disparo pouco frequente de eventos, ou, de modo mais geral, em:

xs.Where(f).Select(p)....

[0052] a origem “xs” produz eventos com pouca frequência,


como determinado pelo componente de processamento 230. Neste
ponto, faria sentido fazer o fluxo de eventos de “xs” disparar a entrada
de página do restante da lógica da consulta. Para tanto, técnicas
similares aos temporizadores podem ser usadas, mas tendo-se em
mente que “xs” pode possuir uma cardinalidade de mais de um;
portanto, é desejável realizar a entrada de página do cálculo uma vez
e não para toda mensagem. Em uma forma geral, a seguinte reescrita
é possível:
20/45

xs.F() == xs.Publish(ys => ys.First().SelectMany(y =>


ys.StartWith(y).F()))

[0053] Isto pode parecer bastante complicado, mas é


necessário no caso geral em que efeitos colaterais são possíveis. Em
particular, pode ser indesejável subscrever-se para “xs” múltiplas
vezes, pois a criação de uma assinatura pode ter um efeito colateral,
tal como entrar em contato com um serviço externo. É nisto que o uso
do operador “Publish” entra em cena. Se “xs” fosse um fluxo quente, o
que significa que as notificações são produzidas independentemente
das assinaturas, em vez de começar a produzir notificações em
resposta a uma assinatura, o operador “Publish” pode ser removido.
Para simplificar o código acima, suponha que “xs” seja um fluxo
quente para o qual é possível se inscrever quantas vezes for desejado:

xs.F() == xs.First().SelectMany(x => xs.StartWith(x).F())

[0054] Agora, se torna mais claro que o carregamento é


postergado para a expressão “F”, que poderia ser arbitrariamente
grande (por exemplo, Where(f).Select(p)), até que o primeiro evento
em “xs” chegue. Para a expressão de consulta original “F” não perder
esse evento, o componente de reescrita 210 pode reinserir a
expressão em frente à nova assinatura para "xs". Isto pressupõe que a
implementação do operador "StartWith" é síncrona e não perderá
eventos recebidos em “xs” entre o momento em que “x” foi recuperado
e a assinatura interna para “xs” é realizada. Se esta garantia não
existir, outros operadores podem ser incorporados para manter um
armazenamento temporário de mensagens.
21/45

[0055] De qualquer maneira, daqui em diante, as mesmas


técnicas que as descritas para os temporizadores se aplicam. A porção
interna do operador “SelectMany” pode ser carregada na memória
tardiamente após a chegada de uma mensagem (para os
temporizadores, isto foi um tique ). Um operador especializado
"PageWhenFirstEventArrives" pode ser construído, o qual faz tudo
isto:

xs.PageWhenFirstEventArrives(ys => ys.F())

[0056] Tal operador pode ser construído como a composição


de operadores como ilustrado acima, ou pode ser construído como sua
própria primitiva que utiliza as mesmas classes de base de operador
de ordem superior que o operador “SelectMany” para reutilizar os
mecanismos de carregamento tardio e de ponto de verificação
existentes. Isto é, nenhum custo para criação de ponto de verificação e
residência em memória é pago para "ys.F()" até que o primeiro evento
chegue. Adicionalmente, o parâmetro para este operador pode ser
abstraído em um artefato carregado radialmente como se segue: –

ctx.DefineObservable(someId, ys => ys.F());


xs.PageWhenFirstEventArrives(someId)

[0057] A paginação disparada por chegada de evento pode


levar a retardos nos processamento de mensagens devido ao tempo
de carregamento. Em colaboração com a coleta de estatísticas, isto
poderia ser atenuado se a próxima chegada de mensagem pudesse
ser prevista, por exemplo, a partir de dados de histórico. Estas
informações podem então ser usadas para criar um sinal à frente do
tempo. Independente disso, o acionamento baseado em eventos ainda
22/45

é necessário no caso de a predição estar errada. Usando esta


observação, a técnica de paginação pode ser generalizada para
permitir um evento de entrada de página que vai além de “xs.First()” ou
um temporizador. Isto é, considere o seguinte operador:

xs.PageIn(ys => pageInEvent, ys => ys.F())

[0058] Aqui, “xs” é alimentado para duas expressões lâmbda,


recebendo o pseudônimo de “ys”. O segundo lâmpada é onde o código
paginável é inserido, como descrito anteriormente. O primeiro lâmbda
proporciona um sinal, que pode ser uma expressão observável
arbitrária, que pode usar a origem “xs” (que recebe o pseudônimo
“ys”). Por exemplo, caso seja desejável carregar na memória o cálculo
quando o primeiro evento cega ou quando um temporizador preditivo
expira, “xs.F()” pode ser reescrito da seguinte maneira:

xs.PageIn(ys => Merge(ys.First(), Timer(t)), ys => ys.F())

[0059] Por reutilizar a composição rica dos operadores de


processamento de eventos, proporciona-se um meio extremamente
flexível para construir um sistema de paginação.
[0060] Dado o mecanismo descrito acima para carregar na
memória o código representando um cálculo de processamento de
evento, dois artefatos em tempo de execução são originados, a saber,
o código que foi carregado na memória e o estado acumulado por um
cálculo recém-iniciado. Quando um cálculo resultante é alimentado
com pouca frequência com novos eventos de entrada (e supondo que
os temporizadores também sejam modelados como fluxos de evento),
é vantajoso poder descarregar o cálculo da memória, incluindo o
código e o estado.
23/45

[0061] Um sistema de processamento de eventos pode


incluir um mecanismo para criar um ponto de verificação do estado.
[0062] Por conseguinte, o suporte existente ao operador para
criação do ponto de verificação do estado pode ser utilizado para dar
suporte à paginação para efetivamente descarregar da memória um
cálculo em execução.
[0063] De modo a oferecer flexibilidade, o operador "PageIn"
descrito acima pode ser incorporado em um operador "Page"
ilustrativo que também recebe um sinal de saída de página:

IObservable<T> Page<T, I, R, 0>(IObservable<T> source,


Func<IObservable<T>, IObservable<I> pageIn,
Func<IObservable<T>, IObservable<R> compute,
Func<IObservable<T>, IObservable<0> pageOut);

[0064] A funcionalidade do operador pode ser construída de


maneira composicional, como ilustrado antes para a porção de entrada
de página. Operacionalmente, o operador “Page” faz várias coisas
durante um ciclo de vida. O operador inscreve-se para uma origem
introduzindo um tema para transmitir mensagens para as funções
fornecidas sem duplicar os efeitos colaterais das assinaturas para a
origem e sem perder mensagens, seja pelo uso de esquemas de
travamento ou pré-carregamento no armazenamento temporário
vinculado. Adicionalmente o operador “Page” executa repetidamente
várias ações. Primeiro, alimentar a origem transmitida para a função
“pageIn” e inscrever-se para seu resultado. Ao receber uma
notificação, alimentar a origem transmitida para a função “compute”,
alimentar os eventos resultantes para um observador a jusante, e
alimentar a origem transmitida para a função “pageOut”. A função
“pageOut” também poderia ser alimentada com mais dados para tomar
24/45

decisões, a título de exemplo, e não limitação, o resultado do cálculo


poderia ser passado para o operador “pageOut” para viabilizar a
medição de uma taxa de eventos e saída de página quando a taxa
tiver ficado em zero por um período prolongado predeterminado.
Quando do recebimento de uma notificação associada à função
“pageOut”, criar um ponto de verificação do estado de cálculo atual,
descarregar da memória os artefatos em tempo de execução, e repetir
o ciclo de vida.
[0065] Um exemplo de uso é apresentado a seguir:

Page(source: xs,
pageIn: ys => Merge(ys.First(), Timer(tl)),
compute: ys => ys.F(),
pageOut: ys => ys.Throttle(t2))

[0066] Até mesmo a função “pageOut” pode ser


descarregada da memória até que a função “pageIn” tenha produzido
uma mensagem. Isto é, o componente de reescrita 210 pode colocar
argumentos carregados tardiamente no lugar da seguinte maneira:

Page(source: xs,
pageIn: ys => Merge(ys.First(), Timer(tl)),
compute: Defer(someId1),
pageOut: Defer(someId2))

[0067] Aqui, “someId1” e “someId2” são definidos como


descrito anteriormente. Operacionalmente, este operador inscreve-se
para “xs” e irá armazenar na memória o cálculo após receber um
primeiro evento ou a chegada de um evento preditivo. O cálculo é
descarregado da memória quando a sequência de entrada passada
25/45

pela função “throttle” recebe um evento; ou seja, se um evento de


entrada não tiver sido seguido por outro evento dentro de um tempo
“t2”, ele se propaga para a função de saída de página e causa uma
saída de página devido a um tempo de inatividade maior do que “t2”.
[0068] O componente de atualização 240 é configurado para
atualizar ou alterar a operação da paginação baseado nos dados ou
informações atuais obtidos a partir do componente de processamento
230 em resposta aos dados de execução de consulta de histórico
capturados. O uso de artefatos ou identificadores definidos
proporciona um nível de indireção que pode ser usado para alterar
dinamicamente funções de paginação associadas ao operador “Page”.

Page(source: xs,
pageIn: Defer(someId3),
compute: Defer(someId1),
pageOut: Defer(someId2))

[0069] No fragmento acima, uma carga postergada para


“pageIn” também foi inserida. Embora isto possa ser um desperdício
para uma assinatura inicial, pode acabar compensando se a consulta
for descarregada repetidamente da memória e voltar. Neste ponto, o
componente de reescrita 210 ou um componente de atualização
separado 240 designado para atualizações pode redefinir “someId3” e
“someId2” em algum ponto para tornar o comportamento de saída de
página menos agressivo e/ou para tornar o comportamento de entrada
de página mais proativo. Para permitir a atualização, as expressões
representando essas funções de página não deverão ser alinhadas
antecipadamente, daí o uso de um operador “Defer”.
[0070] A FIG. 4 é uma ilustração gráfica de uma reescrita
com funções de coleta de estatísticas e paginação baseado nos dados
26/45

de histórico. Começando na esquerda, uma consulta de criação de


cerca virtual 400 é recebida. A consulta de criação de cerca virtual 400
estabelece uma barreira virtual e gera um evento quando “Bart leaves
home”, baseado nos parâmetros “Bart”, “leaves” e “home”. A consulta
de criação de cerca virtual 400 pode ser reescrita para produzir uma
versão paginável 410 da consulta de criação de cerca virtual. A função
de paginação pode ser uma generalização de um operador
“SelectMany”.
[0071] Aqui, a consulta de criação de cerca virtual 400 é
reescrita em duas partes, a primeira parte 420 representando o código
que precisa estar residente na memória e a segunda parte 430
representando o código que não precisa estar residente na memória,
exceto entre a ocorrência de um evento de entrada de página e um
evento de saída de página. O código de coleta de estatísticas também
é adicionado à segunda parte 430 da consulta, que coleta dados
estatísticos relacionados à execução da consulta e salva os dados no
armazenamento de estatísticas de histórico 440. A reescrita também
injeta funcionalidade de entrada de página 450 e funcionalidade de
saída de página 460 que controlam quando a segunda parte 430 da
consulta é permutada para dentro e para fora da memória.
Adicionalmente, a funcionalidade de entrada de página 450 e a
funcionalidade de saída de página 460 são determinadas com base
em estados estatísticos. Como ilustrado no armazenamento de
estatísticas de histórico, as estatísticas podem ser coletadas com base
na execução de consulta anterior, observando quando a cerca virtual é
tipicamente dividida nos parâmetros “Bart”, “leaves” e “home”. Pode
ser determinado ou inferido, com base nos dados, que a cerca virtual é
tipicamente dividida por volta de 8 da manhã.
[0072] Consequentemente, a funcionalidade de entrada de
página 450 pode ser configurada para disparar antes de 8 da manhã
27/45

(por exemplo, 7:45 da manhã) e a funcionalidade de saída de página


pode ser configurada para disparar depois de 8 da manhã (por
exemplo, 8:15). Utilizando uma análise mais avançada, tal como
aprendizado por máquina, pode ser inferido que o disparador para a
consulta é por volta de 8 da manhã em dias úteis e por volta de 10 da
manhã nos finais de semana. Assim, a sequência de eventos para
eventos de entrada e saída de página podem mudar de um
temporizador periódico de vinte e quatro horas (por exemplo, entrada
de página todo dia às 7:45) para uma sequência mais complexa que
leva em conta o padrão descoberto.
[0073] Retornando brevemente à FIG. 1, observe que o
componente otimizador 120 e o componente de paginação 130 são
ilustrados como entidades separadas. É possível que o componente
otimizador 120 possa sugerir uma otimização de consulta que é
essencialmente desfeita pelo componente de paginação 130. Em
outras palavras, o componente de paginação 130 pode subotimizar ou
reverter a otimização de uma consulta otimizada para tornar a consulta
paginável. Por exemplo, o componente otimizador 120 pode delinear
operadores “SelectMany” duplos, mas o componente de paginação
130 pode reverter isso e alinhar os operadores. De acordo com outra
concretização, a funcionalizada do componente de paginação 130
pode ser incorporada dentro do componente otimizador 120 de modo
que o resultado do componente otimizador seja uma consulta
paginável otimizada.
[0074] Os sistemas, arquiteturas, ambientes e similares
mencionados anteriormente foram descritos em relação à interação
entre vários componentes. Deve-se apreciar que tais sistemas e
componentes podem incluir os componentes ou subcomponentes
especificados especificados neste, alguns dos componentes ou
subcomponentes especificados e/ou componentes adicionais. Os
28/45

subcomponentes também poderiam ser implementados como


componentes comunicativamente acoplados a outros componentes,
em vez de incluídos dentro de seus componentes pai. Ademais, um ou
mais componentes e/ou subcomponentes podem ser combinados em
um único componente para proporcionar funcionalidade agregada. A
comunicação entre sistemas, componentes e/ou subcomponentes
pode ser realizada de acordo tanto com um modelo push e/ou pull. Os
componentes também podem interagir com um ou mais componentes
diferentes não descritos especificamente aqui por razões de
brevidade, mas geralmente conhecido pelos versados na técnica.
[0075] Adicionalmente, várias partes dos sistemas revelados
acima e métodos abaixo podem incluir ou empregar componentes,
subcomponentes, processos, meios, metodologias ou mecanismos de
inteligência artificial, aprendizado por máquina, ou baseados em
conhecimento ou regras (por exemplo, máquinas vetoriais de suporte,
redes neurais, sistemas especialistas, redes Baiesianas, lógica difusa,
mecanismos de fusão de dados, classificadores, etc.). Tais
componentes, entre outros, podem automatizar certos mecanismos ou
processos realizados pelos mesmos para tornar partes dos sistemas e
métodos mais adaptáveis, além de eficientes e inteligentes. A título de
exemplo, e não limitação, o componente de processamento 230 pode
empregar tais mecanismos para inferir um período de tempo ativo para
uma consulta fixa pra facilitar a determinação de quando realizar a
entrada de página e a saída de página.
[0076] Em vista dos sistemas exemplificativos descritos
acima, metodologias que podem ser implementadas de acordo com a
matéria revelada serão melhor apreciadas com referência aos
fluxogramas das FIGS 5 a 8. Embora, com o objetivo da simplificar a
explicação, as metodologias sejam ilustradas e descritas como uma
série de blocos, deve-se entender e apreciar que a matéria
29/45

reivindicada não se limita à ordem dos blocos, uma vez que alguns
blocos podem ocorrer em ordens diferentes ou simultaneamente com
outros blocos a partir do que é representado e descrito neste
documento. Além do mais, nem todos os blocos ilustrados são
obrigatórios para implementar os métodos descritos neste documento.
[0077] Referindo-se à FIG. 5, um método 500 para gerar uma
consulta paginável em um sistema de processamento de eventos é
ilustrado. No numeral de referência 510, uma consulta de
processamento de eventos fixa é recebida, recuperada ou de alguma
outra forma obtida ou adquirida. A consulta de processamento de
eventos fixa é avaliada continuamente durante uma sequência ou fluxo
de eventos ao longo do tempo.
[0078] No numeral 520, um disparador de entrada de página
é injetado na consulta. O disparador de entrada de página identifica
quando carregar uma consulta, ou parte da mesma, na memória.
Embora o disparador de entrada de página possa ser definido após a
ocorrência de um evento que é processado por uma consulta, é
preferível que o disparador de entrada de página seja especificado
antes da ocorrência do evento que é processado pela consulta. Isto
pode ser determinado com base nos parâmetros e propriedades
algébricas dos operadores de consulta. Adicionalmente ou como
alternativa, os dados coletados referentes à execução da consulta
podem ser utilizados para determinar e atualizar o disparador de
entrada de página. Na referência 530, a funcionalidade para realizar a
entrada de página, ou, em outras palavras, carregar na memória, uma
consulta, ou uma parte da mesma, é inserida. De acordo com uma
implementação, a funcionalidade de entrada de página pode explorar
recursos do sistema de processamento de eventos, incluindo o
carregamento tardio ou sob demanda de sequências internas de um
operador “SelectMany”, bem como um mecanismo de criação de ponto
30/45

de verificação para carregar a consulta, ou parte da mesma, incluindo


código e estado de captura dos dados. Adicionalmente, pode-se injetar
funcionalidade para obter dados referentes à execução da consulta.
Os tempos ativos, dentre outras coisas, podem ser previstos a partir
desses dados e usados para estabelecer ou atualizar disparadores de
entrada de página e saída de página.
[0079] Um disparador de saída de página é injetado no
numeral 540. O disparador de saída de página indica quando a
consulta pode ser removida ou descarregada da memória. Por
exemplo, isto pode ser após um tempo predeterminado ou após um
tempo de inatividade predeterminado, dentre outras coisas.
Adicionalmente, o disparador de saída de página pode ser gerado e
atualizado com base em dados de execução coletados, tais como
tempos de atividade previstos ou tempo de processamento.
[0080] No numeral de referência 550, é possível inserir
funcionalidade para descarregar a consulta da memória (saída de
página). De acordo com uma implementação, a funcionalidade de
saída de página pode explorar a persistência de estado associada à
criação de ponto de verificação proporcionada pelo sistema de
processamento de eventos. Por exemplo, o código e o estado do
código podem ser salvos em um armazenamento de dados
persistente.
[0081] Subsequentemente, a consulta pode ser removida ou
descarregada da memória. Isto pode ser feito diretamente, por
exemplo, desalocando a memória ou indiretamente, por exemplo,
definindo um ponteiro nulo ou decrementando um contador de
referência até zero para iniciar a coleta de lixo.
[0082] A FIG. 6 representa um método 600 de carregamento
e descarregamento da consulta para e da memória. No numeral 610,
um disparador de entrada de página é detectado. Na referência 620,
31/45

uma consulta de processamento de evento fixa, ou parte da mesma,


compreendendo código e potencialmente estado de captura de dados,
é carregada na memória. Em outras palavras, o código necessário
para avaliar uma consulta em relação aos dados que não estava
anteriormente na memória é carregado para a memória. de acordo
com uma implementação, pode-se empregar a funcionalidade de um
sistema de processamento de consulta que diz respeito ao
carregamento tardio do código para carregar uma consulta na
memória. No numeral de referência 630, um disparador de saída de
página pode ser detectado. Em seguida, em 640, a consulta ou uma
parte da mesma pode ser descarrega da memória. Em uma
implementação, recursos de criação de ponto de verificação de um
sistema de processamento de consulta podem ser utilizados para
salvar código e estado em um armazenamento de dados persistente.
Subsequentemente, a consulta pode ser removida da memória
diretamente por desalocação da memória ou indiretamente pela
atribuição de um ponteiro como nulo ou decrementando um contador
de referência para iniciar a coleta de lixo. De acordo com uma
concretização, toda a consulta, ou parte da mesma, não precisa ser
descarregada da memória; em vez disso, somente um subconjunto da
consulta pode ser descarregado da memória. Por exemplo, em uma
situação em que há consultas aninhadas, pode-se empregar uma
estratégia para seletivamente descarregar da memória partes em
qualquer nível, tal como descarregar da memória da subárvore que
mais consome memória.
[0083] A FIG. 7 ilustra um método 700 de carregamento de
uma consulta na memória. No numeral de referência 710, um
identificador é lido. De acordo com um aspecto da matéria revelada,
um nível de indireção pode ser empregado, em que somente uma
referência para uma consulta, a saber, um identificador, está residente
32/45

na memória. Isto proporciona um mecanismo para postergar o


carregamento da consulta. No numeral de referência 720, uma
consulta ou parte da mesma é localizada, a qual está associada ao
identificador. Por exemplo, uma estrutura de armazenamento de
dicionário ou armazenamento de valores-chaves pode armazenar a
consulta. Neste caso, o identificador é usado como a chave para obter
a consulta armazenada na forma de dados. Em 730, a consulta, ou
parte da mesma, é compilada em código executável. No numeral 740,
o código executável é alinhado na memória. Dito de outra forma, o
código executável é carregado na memória substituindo o identificador.
Finalmente, no numeral de referência 750, o estado relacionado à
consulta é obtido a partir do armazenamento persistente e restaurado.
Evidentemente, se esta for a primeira vez que a consulta foi carregada
na memória, o estado pode ser algum estado inicial, ou absolutamente
nenhum estado.
[0084] A FIG. 8 é um diagrama de fluxo de dados de um
método 800 de descarregamento de uma consulta da memória. No
numeral de referência 810, cria-se um ponto de verificação para a
consulta, ou parte da mesma. Isto pode corresponder a salvar, em um
armazenamento persistente, um identificador vinculado à consulta, a
consulta em si, e o estado da consulta. De acordo com uma
concretização, esta funcionalidade de criação de ponto de verificação
pode ser oferecida por um sistema de processamento de eventos e
meramente invocada para uso no descarregamento de uma consulta
da memória. No numeral de referência 820, partes da consulta a
serem removidas da memória são identificadas. De acordo com uma
concretização, substancialmente toda a consulta, ou todas as partes,
podem ser removidas da memória, exceto quaisquer ganchos
necessários para carregar a consulta na memória. De acordo com
outra concretização, somente um subconjunto da consulta é removido
33/45

da memória, tal como a parte de maior consumo de memória. Em um


exemplo, as consultas podem ser aninhadas e uma estratégia pode
ser implementada para seletivamente remover partes em qualquer
nível. No numeral de referência 830, as partes identificadas da
consulta são removidas da memória. Por exemplo, a consulta pode ser
desalocada diretamente da memória ou indiretamente por coleta de
lixo mediante atribuição de um ponteiro de referência como nulo ou
decrementando um contador de referência até zero.
[0085] Qualquer dados que possam ser representados como
uma sequência de eventos ou fluxo de eventos podem ser usados
como parte de um processo de decisão para uma capacidade de
entrada de página e saída de página. Em um caso particular, os
eventos do sistema, por exemplo, associados à memória física e à
unidade central de processamento, podem ser representados como
um fluxo de eventos. Convencionalmente, os mecanismos de
paginação baseados no sistema operacional lidam exclusivamente
com esses tipos de métricas do sistema. Essas métricas são
secundárias ao processo de decisão específico ao domínio descrito
aqui. De fato, o conhecimento do domínio reduz os casos excepcionais
em que as métricas de nível do sistema são utilizadas para carregar e
descarregar as consultas da memória. No entanto, para tempestades
de eventos, que são situações em que ocorre uma grande quantidade
de eventos durante um período de tempo relativamente curto, ou em
momentos em que a capacidade preditiva não é satisfatória, o sistema
de processamento de eventos pode recuar para a paginação baseada
em eventos do sistema para evitar a alocação de recursos excessivos.
Adicionalmente, em um ambiente distribuído, o processamento de
eventos baseado em eventos do sistema pode ser usado para solicitar
o autobalanceamento da carga por meio da migração do cálculo para
máquinas diferentes.
34/45

[0086] Os aspectos do documento desta revelação são


aplicáveis ao processamento distribuído em grande escala, bem como
ao processamento de dispositivos em pequena escala. Por exemplo,
os aspectos desta revelação podem ser implementados em conjunto
com um sistema de processamento de eventos distribuído ou servido
que processa muitas consultas de muitos usuários. Neste cenário, a
paginação pode aumentar a densidade de memória para auxiliar no
processamento de grandes números de consultas. Os aspectos
também são aplicáveis a dispositivos de computação simples, tal como
um telefone. Aqui, a paginação pode ser empregada para remover
uma ou mais consultas do usuário da memória e um processamento
em segundo plano para conservar a energia da bateria, por exemplo.
[0087] A presente revelação suporta vários produtos e
processos que realizam, ou que são configurados para realizar, várias
ações relacionadas ao carregamento em memória de um sistema de
processamento de eventos. O que se seguem são um ou mais
sistemas e métodos ilustrativos.
[0088] Um sistema compreende um processador acoplado a
uma memória, o processador configurado para executar o seguinte
componente executável por computador armazenado na memória: um
primeiro componente configurado para receber uma consulta de
processamento de eventos; e um segundo componente configurado
para reescrever a consulta de processamento de eventos em uma
forma paginável que suporta a permutação de pelo menos uma parte
da consulta para dentro e para fora da memória. O sistema
reivindicado também pode compreender um terceiro componente
configurado para injetar um disparador de entrada de página que inicia
o carregamento pelo menos da parte da consulta de processamento
de eventos para a memória. Em um exemplo, o disparador de entrada
de página é gerado com base em dados de histórico relacionados à
35/45

execução da consulta de processamento de eventos. O sistema pode


adicionalmente compreender um terceiro componente configurado
para injetar um disparador de saída de página que inicia a remoção de
pelo menos parte da consulta de processamento de eventos da
memória. Em um exemplo, o disparador de saída de página é gerado
com base em dados de histórico relacionados à execução da consulta
de processamento de eventos. O sistema pode adicionalmente
compreender um terceiro componente configurado para coletar dados
relacionados à execução da consulta de processamento de eventos.
[0089] Um método compreende empregar pelo menos um
processador configurado para executar instruções executáveis por
computador armazenadas em uma memória para realizar os seguintes
atos: receber uma consulta de processamento de eventos; e gerar
uma consulta paginável baseado na consulta de processamento de
eventos, em que a consulta paginável suporta a permutação de pelo
menos uma parte da consulta de processamento de eventos para
dentro e para fora da memória. O método adicionalmente compreende
injetar um disparador de entrada de página para iniciar o carregamento
de pelo menos parte da consulta de processamento de eventos para a
memória. O método adicionalmente compreende injetar um disparador
de saída de página para iniciar a remoção de pelo menos parte da
consulta de processamento de eventos da memória. O método
adicionalmente compreende inserir um mecanismo para postergar o
carregamento de pelo menos parte da consulta de processamento de
eventos para a memória até disparado. O método adicionalmente
compreende inserir um mecanismo para coletar dados relacionados à
execução da consulta de processamento de eventos. O método
adicionalmente compreende empregar aprendizado por máquina com
relação aos dados para inferir pelo menos um de um disparador de
entrada de página ou um disparador de saída de página. O método
36/45

adicionalmente compreende inserir um mecanismo para salvar o


estado de pelo menos parte da consulta de processamento de eventos
em conexão com a permutação da consulta de processamento de
eventos para fora da memória. O método adicionalmente compreende
inserir um mecanismo para recuperar o estado de pelo menos parte da
consulta de processamento de eventos em conexão com a
permutação da consulta de processamento de eventos para a
memória. O método adicionalmente compreende inserir um
mecanismo para remover da memória um subconjunto de pelo menos
parte da consulta de processamento de eventos.
[0090] Um meio de armazenamento legível por computador
possuindo instruções nele armazenadas que permitem que pelo
menos um processador realize um método quando da execução das
instruções, o método compreendendo: detectar um disparador de
entrada de página com relação a uma sequência de eventos; e
carregar pelo menos uma parte de uma consulta de processamento de
eventos na memória em resposta à detecção do disparador de entrada
de página. O método de carregamento da consulta de processamento
de eventos pode compreender localizar uma representação de dados
de pelo menos parte da consulta de processamento de eventos
baseado em um identificador; e compilar a representação de dados
para código executável. O método pode adicionalmente compreender
detectar um disparador de saída de página com relação à sequência
de eventos; e descarregar pelo menos parte da consulta de
processamento de eventos da memória em resposta à detecção do
disparador de saída de página. O método de descarregamento da
consulta de processamento de eventos pode compreender iniciar uma
operação de captura de estado que captura o estado atual da consulta
de processamento de eventos. O método de descarregamento da
consulta de processamento de eventos pode compreender
37/45

descarregar somente um subconjunto de pelo menos parte da consulta


de processamento de eventos.
[0091] Os aspectos da presente revelação dizem respeito ao
problema técnica de gerenciamento de memória de computador em
conjunto com o processamento de consultas fixas. Os aspectos
técnicos associados ao enfrentamento deste problema incluem o
emprego de um sistema de processamento de eventos para gerenciar
a memória por meio da reescrita de consultas para dar suporte ao
carregamento e descarregamento da memória. Por conseguinte, os
aspectos da revelação apresentam efeitos técnicos com respeito ao
uso eficiente de recursos, incluindo, mas não limitado à conservação
de memória e ao aumento da velocidade de processamento.
[0092] A palavra "exemplificativo", ou várias formas da
mesma, são usadas aqui para significar que serve de exemplo,
instância ou ilustração. Qualquer aspecto ou projeto descrito no
presente documento como "exemplificativo" não deve ser
necessariamente interpretado como preferido ou favorável em relação
a outros aspectos ou projetos. Adicionalmente, os exemplos são
apresentados somente para fins de clareza e compreensão e não
pretendem limitar ou restringir a matéria reivindicada ou partes
relevantes desta revelação de forma alguma. Deve-se apreciar que um
grande número de exemplos adicionais ou alternativos de escopo
variável poderiam ter sido apresentados, mas foram omitidos por
questões de brevidade.
[0093] Conforme usados neste documento, os termos
“componente” e “sistema”, bem como várias formas dos mesmos (por
exemplo, componentes, sistemas, sub-sistemas...) pretendem referir-
se a uma entidade relacionada a computador, seja em hardware, em
uma combinação de hardware e software, em software ou em software
em execução. Por exemplo, um componente pode ser, sem a isto se
38/45

limitar, um processo em execução em um processador, um


processador, um objeto, uma instância, um executável, um
encadeamento de execução, um programa e/ou um computador. A
título ilustrativo, tanto um aplicativo em execução em um computador
quanto o computador podem ser um componente. Um ou mais
componentes podem residir dentro de um processo e/ou
encadeamento de execução, ao passo que um componente pode estar
localizado em um computador e/ou ser distribuído entre dois ou mais
computadores.
[0094] A conjunção “ou”, como usada nesta descrição e nas
reivindicações anexas, pretende significar um “ou” inclusivo em vez de
um “ou” exclusivo, salvo indicação em contrário ou se o contexto
deixar claro. Em outras palavras, “X” ou “Y” pretende significar
quaisquer permutações inclusivas de “X” e “Y”. Por exemplo, se “’A’
emprega ‘X’, “’A’ emprega ‘Y’”, ou “’A’ emprega tanto ‘X” quanto ‘Y’”,
então “’A’ emprega ‘X’ ou ‘Y’” é satisfeito em qualquer um dos casos
anteriores.
[0095] Além do mais, na medida em que os termos “inclui”,
“contém”, "possui", "tendo", ou variações na forma dos mesmos, são
usados na descrição detalhada ou nas reivindicações, tais termos
pretendem ser inclusivos de uma maneira similar ao termo
“compreendendo”, uma vez que “compreendendo” é interpretado,
quando empregado, como uma palavra de transição em uma
reivindicação.
[0096] De modo a apresentar um contexto para a matéria
reivindicada, A FIG. 9, bem como a discussão seguinte, visam a
apresentar uma breve descrição geral de um ambiente adequado, no
qual é possível implementar os vários aspectos da presente matéria. O
ambiente adequado, entretanto, é apenas um exemplo, e não tem a
39/45

pretensão de sugerir qualquer limitação quanto ao escopo de uso ou


funcionalidade.
[0097] Embora o sistema e os métodos revelados acima
possam ser descritos no contexto geral de instruções executáveis por
computador de um programa que roda em um ou mais computadores,
os versados na técnica irão reconhecer que os aspectos também
podem ser implementados em combinação com outros módulos de
programa ou similares. Geralmente, os módulos de programa incluem
rotinas, programas, componentes, estruturas de dados, dentre outras
coisas, que efetuam tarefas específicas e/ou implementam tipos de
dados abstratos específicos. Além disso, os versados na técnica irão
apreciar que os sistemas e métodos acima podem ser praticados com
várias configurações do sistema de computador, incluindo sistemas de
computador de único processador, multiprocessadores ou processador
de múltiplos núcleos, microdispositivos de computação, computadores
de grande porte, bem como computadores pessoais, dispositivos de
computação portáteis (por exemplo, assistente digital pessoal (PDA),
telefone, relógio, etc.), componentes eletrônicos industriais baseados
em microprocessador ou programáveis pelo consumidor, entre outros.
Os aspectos também podem ser praticados em ambientes de
computação distribuída, nos quais as tarefas são efetuadas por
dispositivos de processamento remoto são ligados por meio de uma
rede de comunicações. No entanto, alguns dos aspectos da matéria
reivindicada, ou mesmo todos, podem ser praticados em
computadores autônomos. Em um ambiente de computação
distribuída, os módulos de programa podem estar localizados em um
dispositivo de armazenamento em memória local ou remota, ou em
ambos.
[0098] Com referência à FIG. 9, é ilustrado um computador
ou dispositivo de computação de propósito geral 902 ilustrativo (por
40/45

exemplo, computador de mesa, laptop, tablet, relógio, servidor, portátil,


componentes eletrônicos industriais ou programáveis do consumidor,
decodificador de sinais, sistema de jogo, nó de computador, etc.). O
computador 902 inclui um ou mais processadores 920, a memória 930,
o barramento do sistema 940, o(s) dispositivo(s) de armazenamento
em massa 950, e um ou mais componentes de interface 970. O
barramento do sistema 940 acopla comunicativamente pelo menos os
constituintes do sistema acima.
[0099] No entanto, deve-se apreciar que, em sua forma mais
simples, o computador 902 pode incluir um ou mais processadores
920 acoplados à memória 930 que executam várias ações executáveis
por computador, instruções e/ou componentes armazenados na
memória 930.
[00100] O(s) processador(es) 920 pode(m) ser
implementado(s) com um processador de propósito geral, um
processador de sinais digitais (DSP), um circuito integrado de
aplicação específica (ASIC), um arranjo de portas programáveis em
campo (FPGA) ou outro dispositivo de lógica programável, lógica
discreta de porta ou transistor, componentes de hardware discretos, ou
qualquer combinação dos mesmos projetada para realizar as funções
descritas aqui. Um processador de propósito geral pode ser um
microprocessador, mas na alternativa, o processador pode ser
qualquer processador, controlador, microcontrolador ou máquina de
estados. O(s) processador(es) 920 também pode(m) ser
implementado(s) como uma combinação de dispositivos de
computação, por exemplo, uma combinação de um DSP e um
microprocessador, uma pluralidade de microprocessadores,
processadores de múltiplos núcleos, um ou mais microprocessadores
em conjunto com um núcleo DSP, ou qualquer outra tal configuração.
41/45

Em uma concretização, o(s) processador(es) pode(m) ser um


processador gráfico.
[00101] O computador 902 pode incluir ou de alguma outra
forma interagir com uma variedade de meios legíveis por computador
para facilitar o controle do computador 902 para implementar um ou
mais aspectos da matéria reivindicada. Os meios legíveis por
computador podem ser qualquer meio disponível que possa ser
acessado pelo computador 902 e inclui meios voláteis e não-voláteis, e
meios removíveis e não-removíveis. Os meios legíveis por computador
podem compreender dois tipos mutuamente exclusivos e distintos, a
saber, meios de armazenamento de computador e meios de
comunicação.
[00102] Os meios de armazenamento de computador incluem
tanto meios voláteis e não-voláteis, quanto removíveis e não-
removíveis, implementados em qualquer método ou tecnologia para
armazenamento de informações, tais como instruções legíveis por
computador, estruturas de dados, módulos de programa ou outros
dados. Os meios de armazenamento de computador incluem
dispositivos de armazenamento, tais como dispositivos de memória
(por exemplo, memória de acesso aleatório (RAM), memória somente
para leitura (ROM), memória somente para leitura programável e
eletricamente apagável EEPROM), etc.), dispositivos de
armazenamento magnético (por exemplo, disco rígido, disco flexível,
cassetes, fita, etc.), discos ópticos (por exemplo, disco compacto (CD),
disco versátil digital (DVD), etc.), e dispositivos de estado sólido (por
exemplo, unidade de estado sólido (SSD), unidade de memória flash
(por exemplo, cartão, stick, pen-drive, etc.)), ou quaisquer outros
meios que armazenam, em vez de transmitir ou comunicar, as
informações desejadas acessíveis pelo computador 902. Por
conseguinte, os meios de armazenamento de computador excluem
42/45

sinais de dados modulados, bem como os descritos em relação aos


meios de comunicação.
[00103] Os meios de comunicação incorporam instruções
legíveis por computador, estruturas de dados, módulos de programa
ou outros dados em um sinal de dados modulado tal como uma onda
portadora ou outro mecanismo de transporte, e incluem quaisquer
meios de distribuição de informações. O termo “sinal de dados
modulados” significa um sinal que uma ou mais de suas características
ajustadas ou alteradas de tal maneira a codificar as informações no
sinal. A título exemplificativo, e sem limitação, os meios de
comunicação incluem meios com fio, tal como uma rede com fio ou
conexão direta com fio, e meios sem fio, tal como acústico, RF,
infravermelho e outros meios sem fio.
[00104] A memória 930 e o(s) dispositivo(s) de
armazenamento em massa 950 são exemplos de meios de
armazenamento legíveis por computador. Dependendo da
configuração exata e do tipo de dispositivo de computação, a memória
930 pode ser volátil (por exemplo, RAM), não-volátil (por exemplo,
ROM, memória flash etc.) ou alguma combinação das duas. A título de
exemplo, o sistema básico entrada/saída (BIOS), incluindo rotinas
básicas para transferir informações entre os elementos dentro do
computador 902, tal como durante a inicialização, pode ser
armazenado na memória não-volátil, enquanto que a memória volátil
pode atuar como uma memória cache externa para facilitar o
processamento pelo(s) processador 920, dentre outras coisas.
[00105] O(s) dispositivo(s) de armazenamento em massa 940
incluem meios de armazenamento de computador removíveis/não-
removíveis, voláteis/não-voláteis, para armazenamento de grandes
quantidades de dados em relação à memória 930. Por exemplo, o(s)
dispositivo(s) de armazenamento em massa 950 incluem, sem a isto
43/45

se limitar, um ou mais dispositivos, tal como uma unidade de disco


óptico magnético, unidade de disco flexível, memória flash, unidade de
estado sólido ou cartão de memória.
[00106] A memória 930 e o(s) dispositivo(s) de
armazenamento em massa 950 podem incluir, ou ter neles
armazenados, o sistema operacional 960, um ou mais aplicativos 962,
um ou mais módulos de programa 964 e dados 966. O sistema
operacional 960 atua para controlar e alocar recursos do computador
902. Os aplicativos 962 incluem ou dentre aplicativo de software e do
sistema, ou ambos, e podem explorar o gerenciamento de recursos
pelo sistema operacional 960 através dos módulos de programa 964 e
dos dados 966 armazenados na memória 930 e/ou no(s) dispositivo(s)
de armazenamento em massa 950 para realizar uma ou mais ações.
Por conseguinte, os aplicativos 962 podem transformar um
computador de propósito geral 902 em uma máquina especializada de
acordo com a lógica fornecida pelos mesmos.
[00107] Toda ou parte da presente matéria reivindicada pode
ser implementada usando técnicas de programação e/ou engenharia
convencionais para produzir software, firmware, hardware ou qualquer
combinação dos mesmos para controlar um computador para realizar
a funcionalidade revelada. A título de exemplo e não de limitação, o
sistema de processamento de eventos 100, ou parte do mesmo, pode
ser, ou formar parte, de um aplicativo 962, e incluir um ou mais
módulos 964 e dados 966 armazenados na memória e/ou no(s)
dispositivo(s) de armazenamento em massa 950 cuja funcionalidade
pode ser realizada quando executada por um ou mais processadores
920.
[00108] De acordo com uma concretização particular, o(s)
processador(es) 920 pode(m) corresponder a um sistema em chip
(SOC) ou arquitetura similar incluindo, em outras palavras, a
44/45

integração tanto do hardware quanto do software em um único


substrato de circuito integrado. Aqui, o(s) processador (920) pode(m)
incluir um ou mais processadores, bem como memória pelo menos
similar ao(s) processador(es) 920 e à memória 930, dentre outras
coisas. Os processadores convencionais incluem uma quantidade
mínima de hardware e software e recorrem extensivamente a
hardware e software externo. Em contrapartida uma implementação
SOC do processador é mais poderosa, uma vez que incorpora nele
hardware e software que permitem funcionalidades específicas sem
precisar recorrer a hardware e software externos, ou somente muito
pouco. Por exemplo, o sistema de processamento de eventos 100 e/ou
a funcionalidade associada podem ser incorporados dentro do
hardware em uma arquitetura SOC.
[00109] O computador 902 também inclui um ou mais
componente de interface 970 que são comunicativamente acoplados
ao barramento do sistema 940 e facilitam a interação com o
computador 902. A título de exemplo, o componente de interface 970
pode ser uma porta (por exemplo, serial, paralela, PCMCIA, USB,
FireWire, etc.) ou um cartão de interface (por exemplo, som, vídeo,
etc.), entre outros. Em uma implementação ilustrativa, o componente
de interface 970 pode ser incorporado como uma interface de
entrada/saída do usuário para permitir que um usuário entre com
comando e informações no computador 902, por exemplo, por meio de
um ou mais gestos ou entradas de voz, através de um ou mais
dispositivos de entrada (por exemplo, dispositivo de apontamento, tal
como um mouse, trackball, caneta Stylus, teclado sensível ao toque,
teclado, microfone, joystick, controle de jogo, antena de satélite,
digitalizador, câmera, outro computador, etc.). Em outra
implementação ilustrativa, o componente de interface 970 pode ser
incorporado como uma interface periférica de saída para fornecer
45/45

saída a meios de exibição (por exemplo, LCD, LED, plasma, etc.), alto-
falantes, impressoras e/ou outros componentes, dentre outras coisas.
Além do mais, o componente de interface 970 pode ser incorporado
como uma interface de rede para permitir a comunicação com outros
dispositivos de computação (não ilustrado), tal como através de um
enlace de comunicação com fio ou sem fio. O que foi descrito acima
inclui exemplos de aspectos da matéria reivindicada. Naturalmente,
não é possível descrever todas as combinações possíveis dos
componentes ou metodologias para fins de descrição da matéria
reivindicada, mas os versados na técnica serão capazes de
reconhecer diversas outras combinações e alterações possíveis da
presente matéria revelada. Logo, a matéria revelada pretende
abranger todas tais alterações, modificações e variações situadas
dentro da essência e do âmbito das reivindicações anexas.
1/3

REIVINDICAÇÕES
1. Sistema de processamento de eventos, caracterizado por
compreender:
um processador acoplado a uma memória, o processador
configurado para executar o seguinte componente executável por
computador armazenado na memória:
um primeiro componente configurado para receber uma
consulta de processamento de eventos; e
um segundo componente configurado para reescrever a
consulta de processamento de eventos em uma forma paginável que
suporta a permutação de pelo menos uma parte da consulta para
dentro e para fora da memória.
2. Sistema, de acordo com a reivindicação 1, caracterizado
por adicionalmente compreender um terceiro componente configurado
para injetar um disparador de entrada de página que inicia o
carregamento de pelo menos parte da consulta de processamento de
eventos na memória.
3. Sistema, de acordo com a reivindicação 2, caracterizado
pelo fato de que o disparador de entrada de página é gerado com base
em dados de histórico relacionados à execução da consulta de
processamento de eventos.
4. Sistema, de acordo com a reivindicação 1, caracterizado
por adicionalmente compreender um terceiro componente configurado
para injetar um disparador de saída de página que inicia a remoção de
pelo menos parte da consulta de processamento de eventos da
memória.
5. Sistema, de acordo com a reivindicação 4, caracterizado
pelo fato de que o disparador de saída de página é gerado com base
em dados de histórico relacionados à execução da consulta de
processamento de eventos.
2/3

6. Método implementado por computador, caracterizado por


compreender:
empregar pelo menos um processador configurado para
executar instruções executáveis por computador armazenadas em
uma memória para realizar os seguintes atos:
receber uma consulta de processamento de eventos; e
gerar uma consulta paginável baseado na consulta de
processamento de eventos, em que a consulta paginável suporta a
permutação de pelo menos uma parte da consulta de processamento
de eventos para dentro e para fora da memória.
7. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender injetar um disparador de entrada de
página para iniciar o carregamento de pelo menos parte da consulta
de processamento de eventos na memória.
8. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender injetar um disparador de saída de
página para iniciar a remoção de pelo menos parte da consulta de
processamento de eventos da memória.
9. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender inserir um mecanismo para postergar
o carregamento de pelo menos parte da consulta de processamento
de eventos para a memória até que seja disparado.
10. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender inserir um mecanismo para coletar
dados relacionados à execução da consulta de processamento de
eventos.
11. Método, de acordo com a reivindicação 10,
caracterizado por adicionalmente compreender empregar aprendizado
por máquina com relação aos dados para inferir pelo menos um de um
disparador de entrada de página ou um disparador de saída de página.
3/3

12. Método, de acordo com a reivindicação 6, caracterizado


por adicionalmente compreender inserir um mecanismo para salvar o
estado de pelo menos parte da consulta de processamento de eventos
em conexão com a permutação da consulta de processamento de
eventos para fora da memória.
13. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender inserir um mecanismo para recuperar
o estado de pelo menos parte da consulta de processamento de
eventos em conexão com a permutação da consulta de
processamento de eventos para a memória.
14. Método, de acordo com a reivindicação 6, caracterizado
por adicionalmente compreender inserir um mecanismo para remover
da memória um subconjunto de pelo menos parte da consulta de
processamento de eventos.
1/1

RESUMO
Patente de Invenção: “PAGINAÇÃO DE SISTEMA DE
PROCESSAMENTO DE EVENTOS”.
Uma consulta paginável pode ser gerada baseado em uma
consulta de processamento de eventos. A consulta paginável é uma
forma da consulta de processamento de eventos que suporta a
permutação da consulta de processamento de eventos para dentro e
para fora da memória. Por exemplo, disparadores de entrada de
página e saída de página podem ser inseridos. Após a detecção de um
disparador de entrada de página, a consulta de processamento de
eventos pode ser carregada para a memória, e após a detecção de um
disparador de saída de página, a consulta de processamento de
eventos pode ser descarregada da memória.

Você também pode gostar