Daniel Fireman

Análise de Vulnerabilidades dos Portais Web das Câmaras Municipais Alagoanas

Anais Estendidos do XIX Simpósio Brasileiro de Sistemas de Informação (SBSI 2023)

Com a popularização do acesso a internet no Brasil, portais eletrônicos governamentais cumprem um... more Com a popularização do acesso a internet no Brasil, portais eletrônicos governamentais cumprem um papel essencial. Com esse crescimento na utilização, sistemas de informação públicos se tornaram um alvo de ataques de criminosos cibernéticos. Este trabalho analisou os portais eletrônicos das 102 câmaras municipais alagoanas de acordo com a classificação The Open Web Application Security Project (OWASP) Top 10 de 2021. Além disso, explicamos essas vulnerabilidades através de correlações com o produto interno bruto e o uso do portal de código aberto Interlegis. Por fim, sugerimos medidas práticas de como melhorar a segurança destes sistemas de informação, os quais são essenciais para a democracia brasileira.

Download

Validation of a simulation model for FaaS performance benchmarking using predictive validation

Cornell University - arXiv, Jun 29, 2021

In the paper Controlling Garbage Collection and Request Admission to Improve Performance of FaaS ... more In the paper Controlling Garbage Collection and Request Admission to Improve Performance of FaaS Applications[30], we verified and evaluated the impact of memory management mechanics of programming languages in the context of Functions as a Service (FaaS) via simulation experiments. The results of this study pointed to an impact of up to 11.68% on the response time of requests when a garbage collector procedure was executed during the execution of a CPU-bound function. As future work, we listed a few threats to the validity of the results attained, and among them, we cited the validation of the simulation model used. The validation of the model is important because it validates the results generated in the simulation experiments, which ensures realistic results. In this work, we proposed and executed a validation to the simulation model used in the previous work. To do so, we run measurement experiments in a public FaaS platform and simulation experiments of the same scenarios using the same simulator of the previous paper. Then, we validate the simulator by comparing the results obtained in both experiments to ensure that the simulation result and the measurement one are equivalent.

Download

Improving Tail Latency of Stateful Cloud Services via GC Control and Load Shedding

2018 IEEE International Conference on Cloud Computing Technology and Science (CloudCom), 2018

Most of the modern cloud web services execute on top of runtime environments like .NET's Comm... more Most of the modern cloud web services execute on top of runtime environments like .NET's Common Language Runtime or Java Runtime Environment. On the one hand, runtime environments provide several off-the-shelf benefits like code security and cross-platform execution. On the other hand, runtime's features such as just-in-time compilation and automatic memory management add a non-deterministic overhead to the overall service time, increasing the tail of the latency distribution. In this context, the Garbage Collector (GC) is among the leading causes of high tail latency. To tackle this problem, we developed the Garbage Collector Control Interceptor (GCI) - a request interceptor algorithm, which is agnostic regarding the cloud service language, internals, and its incoming load. GCI is wholly decentralized and improves the tail latency of cloud services by making sure that service instances shed the incoming load while cleaning up the runtime heap. We evaluated GCI's effectiveness in a stateful service prototype, varying the number of available instances. Our results showed that using GCI eliminates the impact of the garbage collection on the service latency for small (4 nodes) and large (64 nodes) deployments with no throughput loss.

Suporte para a adição de instâncias em tempo de execução no anthill

De um lado, a continua evolucao tecnologica nas diversas areas do conhecimento vem fazendo com qu... more De um lado, a continua evolucao tecnologica nas diversas areas do conhecimento vem fazendo com que conjuntos cada vez maiores de dados se tornem disponiveis, atingindo a ordem de petabytes. Nesse cenario, faz-se imprescindivel a utilizacao de recursos distribuidos para realizar o processamento de dados em tempo habil. Do outro lado, com a popularizacao das plataformas de execucao compostas por estacoes de trabalho, os sistemas de computacao vem se tornando inerentemente dinâmicos: recursos podem ser adicionados ou estao sujeitos a falhas. Entretanto, a utilizacao desses recursos como plataforma de computacao de alto desempenho ainda e restrita, uma vez que o desenvolvimento de sistemas paralelos eficientes e escalaveis se mantem uma tarefa dificil, ate mesmo para programadores experientes.O Anthill e um ambiente de programacao paralela baseado no paradigma filtro fluxo. Esse paradigma permite o processamento eficiente de grandes volumes de dados, uma vez que o paralelismo pode ser e...

Controlling Garbage Collection and Request Admission to Improve Performance of FaaS Applications

2020 IEEE 32nd International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD), 2020

Runtime environments like Java's JRE, .NET's CLR, and Ruby's MRI, are popular choices... more Runtime environments like Java's JRE, .NET's CLR, and Ruby's MRI, are popular choices for cloud-based applications and particularly in the Function as a Service (FaaS) serverless computing context. A critical component of runtime environments of these languages is the garbage collector (GC). The GC frees developers from manual memory management, which could potentially ease development and avoid bugs. The benefits of using the GC come with a negative impact on performance; that impact happens because either the GC needs to pause the runtime execution or competes with the running program for computational resources. In this work, we evaluated the usage of a technique - Garbage Collector Control Interceptor (GCI) - that eliminates the negative impact of GC on performance by controlling GC executions and transparently shedding requests while the collections are happening. We executed experiments simulating AWS Lambda's behavior and found that GCI is a viable solution. I...

Using Load Shedding to Fight Tail-Latency on Runtime-Based Services

Servicos HTTP escritos em linguagens baseadas em runtime sao muito populares nos dias de hoje. Po... more Servicos HTTP escritos em linguagens baseadas em runtime sao muito populares nos dias de hoje. Por se basearem em uma runtime, estes servicos podem usufruir de beneficios como codigo mais seguro, multiplataforma e etc. Todavia, e bem conhecido que pausas da runtime devido a coleta de lixo aumentam o tempo de resposta. Como servicos modernos frequentemente se baseiam em diversas chamadas remotas, o desempenho total do sistema acaba sendo determinado pela cauda da distribuicao de latencia, ao inves da sua media. Como solucao para esse problema, propomos uma combinacao de prevencao de carga e controle das intervencoes causadas por coletores de lixo. Nos implementamos um prototipo em Java e avaliamos o seu desempenho diante de workloads sinteticas. Os resultados mostram uma reducao de aproximadamente 40% na cauda de latencia, mantendo praticamente a mesma vazao e utilizacao de CPU.

Download

Allocation strategies for utilization of space-shared resources in Bag of Tasks grids

Future Generation Computer Systems, 2008

As the adoption of grid computing in organizations expands, the need for wise utilization of diff... more As the adoption of grid computing in organizations expands, the need for wise utilization of different types of resources also increases. A volatile resource, such as a desktop computer, is a common type of resource found in grids. However, using efficiently other types of resources, such as space-shared resources, represented by parallel supercomputers and clusters of workstations, is extremely important, since they can provide great amount of computation power. Using space-shared resources in grids is not straightforward since they require jobs to a priori specify some parameters, such as allocation time and amount of processors. Current solutions (e.g. GRAM) are based on the explicit definition of these parameters by the user. On the other hand, good progress has been made in supporting Bag-of-Tasks applications on grids. This is a restricted model of parallelism on which tasks do not communicate among themselves, making recovering from failures a simple matter of reexecuting tasks. As such, there is no need to specify a maximum number of resources, or a period of time that resources must be executing the application, such as required by space-shared resources. Besides, this state of affairs make it hard for Bag-of-Tasks applications running on grid to leverage from space-shared resources. This paper presents the Explicit Allocation Strategy, in which an adaptor automatically fits grid requests to the resource in order to decrease turnaround time of the application. We compare it with another strategy described in our previous work, called Transparent Allocation Strategy, in which idle nodes of the space-shared resource are donated to the grid. As we shall see, both strategies provide good results. Moreover, they are complementary in the sense that they fulfill different usage roles. The Transparent Allocation Strategy enables a resource owner to raise its utilization by offering cycles that would otherwise go wasted, while protecting the local workload from increased contention. The Explicit Allocation Strategy, conversely, allows a user to benefit from the accesses she has to space-shared resources in the grid, enabling her to natively submit tasks without having to craft (time, processors) requests.

Download

MyGrid: A complete solution for running bag-of-tasks applications

Proc. of the SBRC 2004–Salao de Ferramentas (22nd Brazilian Symposium on Computer Networks–III Special Tools Session), May 1, 2004

Abstract. MyGrid is a complete grid solution for running Bag-of-Tasks applications (ie parallel a... more Abstract. MyGrid is a complete grid solution for running Bag-of-Tasks applications (ie parallel applications whose tasks are independent) over whatever resources are available to the user. MyGrid middleware empowers users to interoperate with heterogeneous computational resources across geographic and administrative boundaries. Due to MyGrid's flexible architecture, it is easy to add a new kind of machine in the grid through an abstraction called grid machine. The grid machines implementations currently available in ...

Download

Prebaking Functions to Warm the Serverless Cold Start

Proceedings of the 21st International Middleware Conference, 2020

Function-as-service (FaaS) platforms promise a simpler programming model for cloud computing, in ... more Function-as-service (FaaS) platforms promise a simpler programming model for cloud computing, in which the developers concentrate on writing its applications. In contrast, platform providers take care of resource management and administration. As FaaS users are billed based on the execution of the functions, platform providers have a natural incentive not to keep idle resources running at the platform's expense. However, this strategy may lead to the cold start issue, in which the execution of a function is delayed because there is no ready resource to host the execution. Cold starts can take hundreds of milliseconds to seconds and have been a prohibitive and painful disadvantage for some applications. This work describes and evaluates a technique to start functions, which restores snapshots from previously executed function processes. We developed a prototype of this technique based on the CRIU process checkpoint/restore Linux tool. We evaluate this prototype by running experiments that compare its start-up time against the standard Unix process creation/start-up procedure. We analyze the following three functions: i) a "do-nothing" function, ii) an Image Resizer function, and iii) a function that renders Markdown files. The results attained indicate that the technique can improve the start-up time of function replicas by 40% (in the worst case of a "do-nothing" function) and up to 71% for the Image Resizer one. Further analysis indicates that the runtime initialization is a key factor, and we confirmed it by performing a sensitivity analysis based on synthetically generated functions of different code sizes. These experiments demonstrate that it is critical to decide when to create a snapshot of a function. When one creates the snapshots of warm functions, the speed-up achieved by the prebaking technique is even higher: the speed-up increases from 127.45% to 403.96%, for a small, synthetic function; and for a bigger, synthetic function, this ratio increases from 121.07% to 1932.49%.

Converting Space Shared Resources into Intermittent Resources for use in Bag-of-Tasks Grids

17th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD'05), 2005

Grid Computing is turning from promise into reality. Naturally, however, this is not happening fo... more Grid Computing is turning from promise into reality. Naturally, however, this is not happening for all applications at once. Bag-of-Tasks (BoT) applications (those parallel applications whose tasks are independent) are, due to their simplicity, the first class of applications to be massively executed on grids (e.g. SETI@home). BoT applications are especially amendable for grid execution because they can run on intermittent resources (i.e. resources with no guarantees on availability or reliability). In this scenario, good performance and reliable results are provided by eager schedulers, which rely on replication to overcome unfortunate task-to-processor assignments. A little surprisingly, however, eager schedulers are not prepared to use space-shared resources (e.g. parallel supercomputers). This happens because using a space-shared resource involves submitting a detailed request to the resource scheduler, specifying the number of processors needed and the amount of time these processors are to be allocated -an information that eager schedulers are not prepared to provide. This is unfortunate because space-shared computers are the most powerful computing resources available today and thus could greatly improve the execution time of BoT applications. This work proposes an automatic way to craft such requests in order to convert space-shared resources into intermittent ones, therefore rendering them naturally usable by eager schedulers. Such conversion is based on adaptive heuristics and allows eager schedulers use such powerful computing resources without modifications.

Download

Converting Space Shared Resources into Intermittent Resources for use in Bag-of-Tasks Grids

by Lauro Beltrao Costa and Daniel Fireman

17th International Symposium on Computer Architecture and High Performance Computing (SBAC-PAD'05), 2005

Grid Computing is turning from promise into reality. Naturally, however, this is not happening fo... more Grid Computing is turning from promise into reality. Naturally, however, this is not happening for all applications at once. Bag-of-Tasks (BoT) applications (those parallel applications whose tasks are independent) are, due to their simplicity, the first class of applications to be massively executed on grids (e.g. SETI@home). BoT applications are especially amendable for grid execution because they can run on intermittent resources (i.e. resources with no guarantees on availability or reliability). In this scenario, good performance and reliable results are provided by eager schedulers, which rely on replication to overcome unfortunate task-to-processor assignments. A little surprisingly, however, eager schedulers are not prepared to use space-shared resources (e.g. parallel supercomputers). This happens because using a space-shared resource involves submitting a detailed request to the resource scheduler, specifying the number of processors needed and the amount of time these processors are to be allocated -an information that eager schedulers are not prepared to provide. This is unfortunate because space-shared computers are the most powerful computing resources available today and thus could greatly improve the execution time of BoT applications. This work proposes an automatic way to craft such requests in order to convert space-shared resources into intermittent ones, therefore rendering them naturally usable by eager schedulers. Such conversion is based on adaptive heuristics and allows eager schedulers use such powerful computing resources without modifications.

Download

A Reconfigurable Run-Time System for Filter-Stream Applications

by Daniel Fireman and André Cardoso

2008 20th International Symposium on Computer Architecture and High Performance Computing, 2008

The development of high level abstractions for programming distributed systems is becoming a cruc... more

Exploiting computational resources in distributed heterogeneous platforms

Proceedings - Symposium on Computer Architecture and High Performance Computing, 2009

We have been witnessing a continuous growth of both heterogeneous computational platforms (e.g., ... more We have been witnessing a continuous growth of both heterogeneous computational platforms (e.g., Cell blades, or the joint use of traditional CPUs and GPUs) and multicore processor architecture; and it is still an open question how applications can fully exploit such computational potential efficiently. In this paper we introduce a run-time environment and programming framework which supports the implementation of scalable and efficient parallel applications in such heterogeneous, distributed environments. We assess these issues through well-known kernels and actual applications that behave regularly and irregularly, which are not only relevant but also demanding in terms of computation and I/O. Moreover, the irregularity of these, as well as many other applications poses a challenge to the design and implementation of efficient parallel algorithms. Our experimental environment includes dual and octa-core machines augmented with GPUs and we evaluate our framework performance for standalone and distributed executions. The evaluation on a distributed environment has shown near to linear scale-ups for two data mining applications, while the applications performance, when using CPU and GPU, has been improved into around 25%, compared to the GPU-only versions.

Download

A Case for Event-Driven Distributed Objects

by Daniel Fireman and Francisco Brasileiro

Lecture Notes in Computer Science, 2006

Much work has been done in order to make the development of distributed systems as close as sensi... more Much work has been done in order to make the development of distributed systems as close as sensible to the development of centralized systems. As a result, there are today good distributed object solutions that closely resemble centralized programming. However, this very attempt to mimic centralized programming implies that distributed objects create the illusion that threads traverse the whole distributed application. This brings all the problems related to multi-thread programming, including the need to reason about the thread behavior of the whole application, which gets amplified by the large scale and inherent non-determinism of distributed systems. Moreover, distributed objects present other troubles when the application is not "pure" client-server, i.e., when the client has other things to do besides waiting for the server. As an alternative, there are a number of message-based non-blocking communication solutions. Unfortunately, these solutions were not designed to directly address the above mentioned issue of multi-threading over the whole distributed application. In addition: (i) these solutions are not as well integrated to the programming language as distributed objects, and (ii) most of them do not provide a well-defined embedded failure detection mechanism, something that is crucial for the development of many distributed systems, and that is well solved by distributed objects (as they couple method invocation and failure detection). We here propose and evaluate an improvement for such a status-quo, named JIC (Java Internet Communication). JIC is an event-driven middleware that relies on a non-blocking communication model, yet providing close semantics to the object-oriented paradigm. JIC is designed to combine the best characteristics of distributed objects and messagebased solutions. For instance, JIC defines precise scope for the application's threads, promotes non-blocking communication, provides a failure detection service that is simple to use with precise semantics, and has performance comparable to Java RMI. Furthermore, JIC is designed to be firewall and NAT friendly, greatly helping the deployment of JICbased applications across multiple administrative domains.

Download

Achieving Multi-Level Parallelism in the Filter-Labeled Stream Programming Model

2008 37th International Conference on Parallel Processing, 2008

AbstractNew architectural trends in chip design resulted in machines with multiple processing un... more

MyGrid: A complete solution for running bag-of-tasks applications

by Lauro Beltrao Costa, Daniel Fireman, and Eliane De Araujo

Proc. of the SBRC 2004–Salao de Ferramentas (22nd Brazilian Symposium on Computer Networks–III Special Tools Session), May 1, 2004

Abstract. MyGrid is a complete grid solution for running Bag-of-Tasks applications (ie parallel a... more Abstract. MyGrid is a complete grid solution for running Bag-of-Tasks applications (ie parallel applications whose tasks are independent) over whatever resources are available to the user. MyGrid middleware empowers users to interoperate with heterogeneous computational resources across geographic and administrative boundaries. Due to MyGrid's flexible architecture, it is easy to add a new kind of machine in the grid through an abstraction called grid machine. The grid machines implementations currently available in ...

Download

Building a User-Level Grid for BoT Applications

Allocation strategies for utilization of space-shared resources in Bag of Tasks grids

by Lauro Beltrao Costa and Daniel Fireman

Future Generation Computer Systems, 2008

As the adoption of grid computing in organizations expands, the need for wise utilization of diff... more As the adoption of grid computing in organizations expands, the need for wise utilization of different types of resources also increases. A volatile resource, such as a desktop computer, is a common type of resource found in grids. However, using efficiently other types of resources, such as space-shared resources, represented by parallel supercomputers and clusters of workstations, is extremely important, since they can provide great amount of computation power. Using space-shared resources in grids is not straightforward since they require jobs to a priori specify some parameters, such as allocation time and amount of processors. Current solutions (e.g. GRAM) are based on the explicit definition of these parameters by the user. On the other hand, good progress has been made in supporting Bag-of-Tasks applications on grids. This is a restricted model of parallelism on which tasks do not communicate among themselves, making recovering from failures a simple matter of reexecuting tasks. As such, there is no need to specify a maximum number of resources, or a period of time that resources must be executing the application, such as required by space-shared resources. Besides, this state of affairs make it hard for Bag-of-Tasks applications running on grid to leverage from space-shared resources. This paper presents the Explicit Allocation Strategy, in which an adaptor automatically fits grid requests to the resource in order to decrease turn-around time of the application. We compare it with another strategy described in our previous work, called Transparent Allocation Strategy, in which idle nodes of the space-shared resource are donated to the grid. As we shall see, both strategies provide good results. Moreover, they are complementary in the sense that they fulfill different usage roles. The Transparent Allocation Strategy enables a resource owner to raise its utilization by offering cycles that would otherwise go wasted, while protecting the local workload from increased contention. The Explicit Allocation Strategy, conversely, allows a user to benefit from the accesses she has to space-shared resources in the grid, enabling her to natively submit tasks without having to craft (time, processors) requests.

Download

Uploads

Papers by Daniel Fireman

Log In