Università degli Studi di Roma Tor Vergata. Gestione Big Data. Manuel Fiorelli

Transcript

1 Università degli Studi di Roma Tor Vergata Gestione Big Data Manuel Fiorelli

2 11/12/ Volume e Velocity I Big Data sono spesso caratterizzati in termini di 5 V (cui talvolta ne sono aggiunte altre): volume, variety, velocity, value, veracity. In particolare, la necessità di gestire grandi quantità di dati (volume) e di reagire prontamente al loro arrivo (velocity) pongono delle sfide alle architetture tradizionali di elaborazione dei dati.

3 11/12/ Quanto Grande? Jacobs (2009) ci fornisce una "meta-definizione" di Big Data incentrata sul concetto di Volume: "big data should be defined at any point in time as data whose size forces us to look beyond the tried-and-true methods that are prevalent at that time. Alcune osservazioni: Questa definizione ignora le altre V dei Big Data L'asticella di quanto un dataset debba essere grande per definirsi "big data" varia col tempo (aumentando col progresso tecnologico)

4 11/12/ Quanto Grande? Alcuni spunti tratti da Jacob (2009): transaction processing e data storage sono problemi largamente risolti è più facile inserire (get in) dati in un database relazionale che tirarli fuori (get out) le vere patologie dei Big Data sono quelle dell'analisi

5 11/12/ Quanto Grande? Oggigiorno si può considerare sufficientemente grande un dataset che non può essere caricato in un database relazionale ed essere elaborato con l'ausilio di pacchetti desktop di analisi/visualizzazione. [Jacob(2009)] Jacob (2009) ci fa l'esempio di un dataset di quasi 7 miliardi di record: Si può salvare su un comune hard disk Semplicemente leggendo il file, si può rispondere ad alcune semplici domande in modo rapido (mix, max, media), ma non rispondere a domande più complesse Con un po' di fatica si riesce a caricare su un RDBMS Le query SQL di analisi sono oltremodo lente

6 11/12/ No Limiti Software Un programma non dovrebbe avere limiti arbitrari circa la dimensione dei dati che può gestire In teoria, un programma dovrebbe essere in grado di sfruttare tutte le risorse hardware disponibili (cpu, memoria, disco) fino ad esaurirle

7 11/12/ Free Lunch Per molto tempo i programmi (ben scritti) hanno beneficiato gratuitamente dell'aumento delle prestazione dell'hardware, in particolar modo della CPU: Un processore col doppio della frequenza di clock dovrebbe essere in grado di eseguire lo stesso programma sequenziale due volte più velocemente

8 11/12/ Free Lunch is Over Ci sono però dei limiti (anche di natura fisica) sulle risorse hardware di una singola macchina. Diversi fattori (tra cui limiti nella dissipazione del calore) hanno arrestato la corsa ai GHz nello sviluppo dei processori. Siamo entrati nell'era dei processori multi-core. Tuttavia, un programma single-threaded può sfruttare un solo core. Un programma si può avvantaggiare dei processori multi-core solo se è multi-threaded: The free lunch is over (Sutter, 2004)

9 11/12/ Difficoltà della concorrenza (1/2) Lo sviluppo dei programmi concorrenti presenta dei problemi: È difficile (es. deadlock, livelock, starvation, race, etc ) Non tutti i programmi sono facilmente parallelizzabili La legge di Amdahl pone un limite allo speedup di un programma (cioè di quante volte si riduce il suo tempo di esecuzione) T 1 = T ser + T par T P T ser + T par = ft P f T 1 P dove fè la frazione seriale non parallelizzabile del lavoro totale S P = T 1 T P T 1 ft f T 1 P S lim P 1 f + 1 f P 1 f + 1 f P Un programma che spende l'1% del proprio tempo di esecuzione a svolgere lavoro non parallelizzabile non potrà avere uno speedup superiore a 100. = 1 f

10 11/12/ Difficoltà della concorrenza (2/2) La legge di Amdahl assume che il workload di un programma sia fisso e che l'obiettivo sia ridurre il tempo di esecuzione. La legge di Gustafson-Barsis, invece, si occupa della capacità di scalare a problemi di dimensione maggiore. Se la parte seriale è costante, oppure cresce più lentamente di quella parallelizzabile, allora lo speedup cresce insieme al numero di processori.

11 11/12/ Sistemi Distribuiti Le risorse disponibili su una sola macchina sono comunque limitate. Cosa fare quando non sono più sufficienti? Comprare un'altra macchina ed usarla insieme alla precedente: Siamo entrati nel mondo dei sistemi distribuiti

12 11/12/ Difficoltà dei Sistemi Distribuiti A prima vista potrebbero sembrare non molto diversi da programmi concorrenti (soprattutto quelli non sfruttano la memoria condivisa). In realtà, lo sviluppo di sistemi distribuiti è ancora più complesso: È difficile distinguere un nodo eccessivamente lento da uno fallito È difficile sapere se un comando è stato effettivamente eseguito È difficile fare in modo che i nodi trovino un consenso su qualcosa Etc.

13 11/12/ Sistemi per il calcolo distribuito Ciò di cui abbiamo bisogno è un computing model che ci permetta di esprimere facilmente la computazione di cui abbiamo bisogno, delegando i dettagli della sua esecuzione ad un framework che deve gestire le complessità dei sistemi distribuiti: Fault tolerance Data distribution Parallelization Load balancing

14 11/12/ Bounded Dataset vs Unbounded Dataset Bounded Dataset: Un insieme finito di dati disponibili tutti qui ed ora Unbounded Dataset: Dati in continuo arrivo Spesso associati alla parola "streaming"

15 11/12/ Unbounded Dataset 2 domini temporali Un unbounded dataset è caratterizzato da due domini temporali: Tempo dell'evento: istante in cui l'evento descritto da un dato è effettivamente occorso Tempo dell'elaborazione: istante in cui il dato entra all'interno del sistema di elaborazione Spesso c'è una differenza non costante tra i due, chiamata skew. Quando si è interessati a ragionare sul tempo dell'evento, lo skew può complicare la generazione di risultati corretti.

16 11/12/ Elaborazione di bounded dataset I bounded dataset sono generalmente elaborati con sistemi di tipo batch: MapReduce ne è un esempio

17 11/12/ Elaborazione di unbounded dataset Un dataset unbound può essere elaborato in vari modi: Batch Streaming

18 11/12/ Elaborazione di unbounded dataset - batch I dati sono bufferizzati (secondo una logica di windowing) creando una sorta di bounded dataset, che può essere elaborato con un sistema di tipo batch: Se l'event time è rilevante, allora abbiamo possibili problemi di incompletezza L'analisi di una sessione utente potrebbe essere suddivisa tra più batch (se la sessione dura più della finestra)

19 Elaborazione di unbounded dataset - streaming 11/12/ Ci sono diversi approcci di elaborazione streaming: Time-agnostic Approximation Windowing by processing time Windowing by event time

20 Elaborazione di unbounded dataset streaming time agnostic 11/12/ L'elaborazione di stream quando il tempo non interessa: Filtrare i dati Calcolare la join di due dataset. Un dato è bufferizzato finché non arriva un messaggio corrispondente. Tuttavia, se questo messaggio potesse non esistere, occorrerebbe inserire un timeout, quindi una nozione di tempo

21 Elaborazione di unbounded dataset streaming approximation 11/12/ Non entreremo nei dettagli. Ci sono degli algoritmi in grado di approssima certe quantità (es. numero di valori unici) in maniera "memoryless" È difficile inventarne uno nuovo Spesso alcune garanzie teoriche di accuratezza dipendono dal processing time (invece che dall'event time)

22 Elaborazione di unbounded dataset streaming widowing 11/12/ Posso suddividere i dati in ingresso in finestre (fisse, scorrevoli o sessioni) secondo il processing time o l'event time: Nel secondo caso è difficile giudicare la completezza di una finestra: Ci si può basare su delle euristiche Oppure, chiedere all'"esterno" quando i dati vanno materializzati Procedure per raffinare i dati nel tempo

23 11/12/ MapReduce Introdotto da Google per risolvere i propri problemi di Big Data (es. indicizzazione del Web) Ispirato alle primitive map e reduce del linguaggio di programmazione funzionale Lisp Utilizzando un approccio funzionale, può sfruttare la ri-esecuzione come meccanismo principale di fault tolerance

24 11/12/ MapReduce primitive Un job MapReduce prende in ingresso una collezione di coppie <K 1, V 1 > e produce una collezione di coppie <K 2, V 2 > L'utente deve specificare due operazioni: map: <K 1, V 1 > List<<K 2, V 2 >> per ciascuna coppia di input genera un numero arbitrario di coppie chiavevalore intermedie reduce: <K 2, List<V 2 >> List<V 2 > ricevendo in ingresso una chiave intermedia e l'insieme di valori per quella chiave (generati da diversi coppie di input), fonde i diversi valori, producendone in genere zero o uno

25 11/12/ MapReduce esempio (1/2) map(string key, String value): // key: document name // value: document contents for each word w in value: EmitIntermediate(w, "1"); reduce(string key, Iterator values): // key: a word // values: a list of counts int result = 0; for each v in values: result += ParseInt(v); Emit(AsString(result));

26 11/12/ MapReduce esempio (2/2) (the, 1) (cat, 1) (a, 1) (a, 1) (a, 2) the cat (the, 1) (cat, 1) the dog (cat, 2) (dog, 1) (cat, 1) a cat a dog (a, 1) (a, 1) (the, 1) (dog, 1) (dog, 1) (cat, 1) (the, 1) (dog, 1) (dog, 2) (the, 2)

27 11/12/ MapReduce map task Se map è una funzione pura, può essere eseguita in parallelo su porzioni differenti dell'input. Da ciò l'idea di suddividere l'input in tanti blocchi (di 64MB) ciascuno dei quali è un map task, che può essere assegnato (scheduled) su uno dei nodi worker. Solitamente il numero di map task viene indicato con M.

28 11/12/ MapReduce reduce task Per quanto riguarda la funzione reduce, lo spazio delle chiavi intermedie viene partizionato. Ciascuna partizione diventa un reduce task, che può essere assegnato (scheduled) su uno dei nodi worker. Se R è il numero di reduce task, una funzione di partizionamento può essere: hash(k 2 ) mod R

29 11/12/ MapReduce DFS (1) Il computing model MapReduce è abbinato ad un filesystem distribuito (DFS): Ciascun file di input è suddiviso in blocchi di dimensione fissa Ciascun blocco viene immagazzinato su un data node e la posizione dei diversi blocchi è immagazzinata su un name node (responsabile del namespace) Fault tolerance (rispetto ai guasti dei data node) ottenuta replicando ciascun blocco su un numero (stabilito) di data node (secondo varie policy)

30 11/12/ MapReduce DFS (2) Come si combinano MapReduce e DFS? Si cerca di assegnare a ciascun worker map task relativi a blocchi che sono replicati su quella macchina (località) Il woker responsabile di un map task scriverà le chiavi intermedie su tanti file nel proprio file system locale quanti sono i reduce task Ciascun reduce task chieve legge (tramite RPC) il contenuto del filesystem locale di ciascun mapper, e produce un file nel DFS (ordinato per chiave) con il risultato del proprio lavoro.

31 MapReduce esecuzione 11/12/

32 11/12/ MapReduce fault tolerance Se un worker fallisce: map task completati sono rieseguiti, perché il loro output non è più accessibile (si trova nel filesyste locale) reduce task completati non sono rieseguiti, perché il loro output è stato salvato nel DFS (quindi i blocchi si trovano, possibilmente replicati, su altri nodi)

33 11/12/ MapReduce alcune ottimizzazioni combiner: Effettuano una riduzione parziale localmente a ciascun map task. In molti casi, il combiner è banalmente il reducer. backup task: Talvolta un task può richiedere molto più tempo del previsto (per diversi ragioni): quando il processo di MapReduce è prossimo al completamento, il master avvia delle copie di backup dei task ancora running, per evitare che il processo sia rallentato da questi task che sono più lenti del normale.

34 11/12/ MapReduce algoritmi iterativi MapReduce non è particolarmente indicato per implementare algoritmi iterativi su grafi: Occorre gestire (fuori dal framework) una sequenza di job MapReduce (sconvenienza) La natura funzionale del modello computazione ci costringe spesso a copiare l'intero grafo da un'iterazione all'altra (inefficienza) Per ovviare a queste limitazioni, Google ha introdotto il modello Pregel.

35 11/12/ Pregel Pregel è un computing model idoneo allo sviluppo di algoritmi iterativi su grafi. Pregel è ispirato al Bulk Synchronous Parallel model. La computazione è una sequenza di superstep Durante il superstep S, per ogni vertice V viene eseguita (concettualmente in parallelo) una funziona decisa dall'utente che: Può leggere i messaggi che sono stati inviati al nodo durante il superstep S-1 Può inviare messaggi ad altri nodi (in genere, collegati tramite archi uscenti), che li riceveranno nel superstep S+1 Può modificare lo stato nel vertice Può modificare la topologia (aggiungere/rimuovere archi e nodi) Può votare di terminare la computazione La computazione termina quando tutti i vertici hanno votato così Un vertice che ha votato la terminazione, non viene più eseguito a meno che non riceva dei messaggi

36 11/12/ Pregel gestione della concorrenza Il modello di computazione adottato da Pregel: Si presta bene alla parallelizzazione, perché non c'è alcun meccanismo di rilevare l'ordine di esecuzione all'interno di un superstep e tutte le comunicazioni avvengo da un superstep al successivo Naturalmente privo di deadlock e data race

37 11/12/ Pregel calcolo del valore massimo Le linee tratteggiate rappresentano messaggi. I nodi ingrigiti hanno votato per la terminazione.

38 11/12/ Pregel single-source shortest path Si consideri un grafo diretto i cui archi hanno pesi strettamente positivi Si vuole calcolare la lunghezza del cammino minimo da un vertice n verso tutti gli altri vertici

39 11/12/ Pregel single-source shortest path Nello stato di ogni vertice c'è una variabile dove verrà inserita la lunghezza del cammino minimo da n Inizialmente queste variabili hanno tutte valore INF Al superstep 0: n setta la propria variabile a 0, ed invia un messaggio a tutti i nodi raggiungibili con archi uscenti un messaggio contenente il peso dell'arco Al superstep S+1 Ciascun vertice legge tutti i messaggi in ingresso, e calcola il valore minimo (che sarebbe una nuova stima della sua distanza da n). Se questo valore è inferiore a quello nella propria variabile: i) aggiorna la variabile, ii) invia ai nodi uscenti un messaggio, pari alla somma del valore e del peso dell'arco. In ogni caso, il vertice vota per terminare. Ad un certo punto, non ci sono più messaggi, tutti i vertici hanno votato per terminare, quindi la computazione termina. La variabile associata a ciascun nodo conterrà la lunghezza del cammino minimo da n (oppure INF se non può essere raggiunto).

40 11/12/ Pregel combiner Nell'esempio precedente, un vertice è interessato soltanto al minimo dei valori contenuti nei messaggi di cui è destinatario. È possibile ridurre l'invio (eventualmente tra nodi remoti) e la bufferizzazione dei messaggi tramite un combiner: una funzione (scelta) dall'utente per accorpare più messaggi: Nell'esempio precedente è sufficiente una funzione minimo

41 11/12/ Apache Hadoop L'implementazione di MapReduce fatta da Google è proprietaria, ed usata internamente dal motore di ricerca di Mountain View. Gli altri possono usare il "clone open-source" Apache Hadoop.

42 11/12/ Apache Hadoop 2 Nella versione 2, l'introduzione di YARN per la gestione del cluster, ha permesso ad Hadoop di svincolarsi da MapReduce (quale unico programming model)

43 11/12/ HDFS - Assunzioni Hadoop Distributed Filesystem (HDFS) è il filesystem distribuito alla base di Apache Hadoop. Principali assunzioni: Hardware failure: tolleranza ai guasti implementata al livello applicativo (principalmente attraverso la replicazione dei blocchi di dati) Streaming Data Access: orientato alle applicazioni batch, piuttosto che all'uso interattivo. Favorisce il throughput alla latency Large Data Sets: decine di milioni di file da GB a TB. Scalabilità a centinaia di nodi Simple Coherency Model: una volta che un file è stato chiuso, è solo possibile appendervi del contenuto oppure troncarlo "Moving Computation is Cheaper than Moving Data": HDFS fornisce delle interfacce che permettono alle applicazioni di spostarsi vicino a dove i dati sono effettivamente immagazzinati Portability across Heterogeneous Hardware and Software Platforms

44 11/12/ HDFS - Architettura

45 11/12/ HDFS - Cartoon

46 11/12/ YARN - Architettura

47 11/12/ HDFS Assunzioni Hadoop Distributed Filesystem (HDFS) è il filesystem distribuito alla base di Apache Hadoop. Principali assunzioni: Hardware failure: tolleranza ai guasti implementata al livello applicativo (principalmente attraverso la replicazione dei blocchi di dati) Streaming Data Access: orientato alle applicazioni batch, piuttosto che l'uso interattivo. Favorisce il throughput alla latency Large Data Sets: decine di milioni di file da GB a TB. Scalabilità a centinaia di nodi Simple Coherency Model: una volta che un file è stato chiuso, è solo possibile appendervi del contenuto oppure troncarlo "Moving Computation is Cheaper than Moving Data": HDFS fornisce delle interfacce che permettono alle applicazioni di spostarsi vicino a dove i dati sono effettivamente immagazzinati Portability across Heterogeneous Hardware and Software Platforms

48 11/12/ Hadoop Modailità d'uso Modalità locale (standalone) [default] Eseguito come un singolo processo Java Utile per il debugging Modalità pseudodistribuita Eseguito come un insieme di processi (NameNode, DataNode, Secondary NameNode, ResourceManager, NodeManager, WebAppProxy and Map Reduce Job History Server) su una singola macchina Modalità pienamente distribuita I vari processi elencati in precedenza sono distribuiti su più macchine

49 11/12/ Hadoop MapReduce InputFormat Un InputFormat describe la specifica di input per un job MapReduce. Il framework MapReduce si affida all'inputformat del job per: Validare la specifica del'input del job. Suddividere i file di in istanze di InputSplit, ciascuna delle quali è assegnato ad un Mapper invididuale. Fornire l'implementazione del RecordReader per estrarre dall'inputsplit i record che saranno elaborate dal Mapper.

50 11/12/ Hadoop MapReduce InputSplit InputSplit rappresenta i dati che devono essere elaborati da un certo Mapper. Tipicamente InputSplit presenta un visione dell'input orientata ai byte, ed è responsabilità del RecordReader elaborarla e presentare una visione a record. FileSplit è l'inputsplit predefinito. Esso setta mapreduce.map.input.file al path del file di input dello split logico.

51 11/12/ Hadoop MapReduce RecordReader Un RecordReader legge coppie <key, value> da un InputSplit. Tipicamente un RecordReader converte la visione dell'input orientata ai byte, fornita da un InputSplit, e presenta una visione a record alle implementazioni di Mapper per l'elaborazione. Il RecordReader assume pertanto la responsabilità di elaborare i confini dei record e presentare ai task chiavi e valori.

52 11/12/ Hadoop MapReduce OutputFormat OutputFormat descrive la specifica di output per un job MapReduce. Il framework MapReduce si affida all'outputformat del job per: Validare la specifica di output del job; per esempio, controllare la cartella di output non esista già. Fornire l'implementazione di RecordWriter usata per scrivere i file di output del job. I file di output solo immagazzinati in un FileSystem. TextOutputFormat è l'outputformat predefinito.

53 11/12/ Hadoop MapReduce Counter I counters rappresentano contatori globali, definiti dal framework MapReduce o dalle applicazioni. Ogni Counter può essere di qualunque tipo Enum. Contatori di un particolare Enum sono messi insieme in gruppi di tipo Counters.Group.

54 11/12/ Hadoop MapReduce SkipBadRecords Hadoop fornisce un'opzione dove un certo insieme di input record cattivi può essere saltato durante la fase di map. Le applicazioni possono controllare questa feature attraverso la classe SkipBadRecords.

55 11/12/ Hadoop MapReduce input/output multipli La classe MultipleInputs supporta job MapReduce con più input path aventi ciascuno un InputFormat e Mapper diversi. p/mapreduce/lib/input/multipleinputs.html La classe MultipleOutputs semplifica la scrittura su più file di output. p/mapreduce/lib/output/multipleoutputs.html

56 11/12/ Hadoop MapReduce lib Nel package org.apache.hadoop.mapreduce.lib si trova una libreria di classi di interesse.

57 Hadoop MapReduce scrivere soltanto i valori 11/12/ Per scrivere soltanto I valori si può usare NullWritable come tipo di output.

58 11/12/ Hadoop Modalità locale (default) Comandi per shell Unix. Per la PowerShell di Windows è sufficiente usare il backslash Esegue un JAR. $ mkdir input $ cp etc/hadoop/*.xml input $ bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples jar grep input output 'dfs[a-z.]+' $ cat output/*

59 11/12/ Apache Spark Lightening-fast unified analytics engine. Modello di computazione DAG, scheduler, ottimizzatore ed esecutore allo stato dell'arte. Evita scrittura dei risultati intermedi in computazioni iterative. Un'API di basso livello su cui sono implementate API di più alto livello per diversi scenari, con prestazioni comparabili o migliori a quelle ottenute con sistemi dedicati

60 11/12/ Apache Spark Apache Spark può essere eseguito su una singola macchina, oppure su un cluster, su EC2, YARN, Mesos o Kubernetes. Apache Spark può accedere a sorgenti di dati diverse, incluso HDFS, HBASE, Cassandra, Hive.

61 11/12/ Apache Spark 3 API Resilient Distributed Dataset (RDD) Una collezione immutabile di elementi partizionati tra i nodi del cluster su si può operare in parallelo attraverso trasformazioni e azioni DataFrame Una collezione distribuita di dati organizzati in colonne dotate di un nome elaborata con SparkSQL Dataset Una collezione distribuita di dati (fortemente tipizzata) che beneficia del motore di esecuzione ottimizzato di SparkSQL

62 11/12/ Apache Spark 3 API

63 11/12/ Apache Spark RDD Un RDD può essere costruito a partire da una qualunque sorgente supportata da Spark oppure parallelizzando una collezione nel programma. Il seguente snippet crea un RDD i cui elementi sono le righe del file. JavaRDD<String> distfile = sc.textfile("data.txt"); Nel caso di un file in HDFS il partizionamento è guidato dalla suddivisione in blocchi.

64 11/12/ Apache Spark RDD Due tipi di operazioni: Trasformazioni: creano un nuovo RDD da uno esistente Azioni: restituiscono un valore al driver Le trasformazioni sono lazy, in quanto eseguite solo quando un'azione richiede di restituire un valore al driver. Le trasformazioni sono ricalcolate ogni volta che eseguiamo le azioni, a meno che l'rdd non sia persistito: ciò è necessario per gli algoritmi iterativi.

65 11/12/ Apache Spark RDD JavaRDD<String> lines = sc.textfile("data.txt"); JavaPairRDD<String, Integer> pairs = lines.maptopair(s -> new Tuple2(s, 1)); JavaPairRDD<String, Integer> counts = pairs.reducebykey((a, b) -> a + b);

66 Apache Spark RDD - Trasformazioni 11/12/

67 Apache Spark RDD Azioni 11/12/

68 11/12/ Apache Spark RDD Altre cose Broadcast variable Accumulator variable Persistence

69 11/12/ Apache Spark DataFrame Dataset<Row> df = spark.read().json("examples/src/main/resources/people.json"); // Displays the content of the DataFrame to stdout df.show(); // // age name // // null Michael // 30 Andy // 19 Justin //

70 11/12/ Apache Spark DataFrame // Select everybody, but increment the age by 1 df.select(col("name"), col("age").plus(1)).show(); // // name (age + 1) // // Michael null // Andy 31 // Justin 20 //

71 Apache Spark Dataset Encoder<Person> personencoder = Encoders.bean(Person.class); Dataset<Person> javabeands = spark.createdataset( ); Collections.singletonList(person), personencoder javabeands.show(); // // age name // // 32 Andy // Gli RDD utilizzano la Serialization standard oppure Kryo; I dataset usano invece gli Encoder. La differenza è che questi ultimi usano un formato che permette a Spark di eseguire varie operazioni (filtering, hashing, sorting, ) senza dover deserializzare l'oggetto 11/12/

72 11/12/ Apache Spark Dataset Dataset<String> names = people.map((person p) -> p.name, Encoders.STRING)); // in Java 8

73 11/12/ Apache Spark Dataset vs RDD I Dataset tipizzati assomigliano molto agli RDD in termini di type safety ed utilizzo di funzioni lambda. Tuttavia, la maggiore struttura dei Dataset e dei DataFrame permette l'uso dell'ottimizzatore Catalyst: Applica diverse ottimizzazioni logiche (es. filter push down) Genera bytecode JVM ottimizzato per il piano fisico di esecuzioni, scegliendo tra diversi algoritmi (es. vari tipi di join)

74 11/12/ Apache Spark GraphX GraphX introduce il tipo Graph per rappresentare un multigrafo con proprietà associate sia ai vertici sia agli archi. class Graph[VD, ED] { val vertices: VertexRDD[VD] val edges: EdgeRDD[ED] } VertexRDD[VD] = RDD[(VertexId, VD)] EdgeRDD[ED] = RDD[Edge[ED]]

75 11/12/ Apache Spark GraphX GraphX definisce degli operati su grafi che utilizzano funzioni definite dall'utente e che producono nuovi grafi con proprietà e struttura cambiate. Supporta l'api Pregel per implementare algoritmi iterativi. Fornisce una libreria di algoritmi pronti.

76 11/12/ Apache UIMA-AS UIMA-AS (Asynchronous Scaleout) è un'estensione del framework Apache UIMA per l'esecuzione su un cluster di macchine. Utilizza un queue broker per mettere in comunicazione le varie parti del sistema.

77 11/12/ Apache UIMA-AS Diverse configurazioni di scaleout.

78 11/12/ Riferimenti (1/3) Dean J., & Ghemawat, S. (2004). MapReduce: Simplified Data Processing on Large Clusters. In Proceedings of OSDI 04: 6th Symposium on Operating Systems Design and Implementation (pp ). ACM Jacobs, A. (2009). The pathologies of big data. Queue, 7(6), 10. Malewicz, G., Austern, M. H., Bik, A. J., Dehnert, J. C., Horn, I., Leiser, N., & Czajkowski, G. (2010, June). Pregel: a system for large-scale graph processing. In Proceedings of the 2010 ACM SIGMOD International Conference on Management of data (pp ). ACM.

79 11/12/ Riferimenti (2/3) McCool, M., Robison, A., & Reinders, J. (2013). Amdahl's Law vs. Gustafson-Barsis' Law. Available at: Sutter, H. (2005). The free lunch is over: A fundamental turn toward concurrency in software. Dr. Dobb s journal, 30(3), Available at: Zaharia, M., Xin, R. S., Wendell, P., Das, T., Armbrust, M., Dave, A.,... & Ghodsi, A. (2016). Apache spark: a unified engine for big data processing. Communications of the ACM, 59(11),

80 11/12/ Riferimenti (3/3) Apache Hadoop: Apache Hadoop 2 is now GA!: Databricks Glossary: Introducing DataFrames in Apache Spark for Large Scale Data Science: The world beyond batch: Streaming 101: Getting Started: Apache UIMA Asynchronous Scaleout: