aller diffuser

diffuser

Cette bibliothèque est un cadre pour l'analyse du traitement de flux. Il est destiné à être utilisé comme bibliothèque pour les programmes Go qui doivent traiter en continu de gros volumes de données.

Il est constitué d'un graphe reliant une source à 1 ou plusieurs opérateurs, se terminant par un puits. Les opérateurs transmettent des données les uns aux autres avec les canaux Go. Un exemple de graphique pour encoder des objets en Snappy est :

 var from *util.MemoryBuffer
// fill up from

var to *util.MemoryBuffer

ch := stream.NewOrderedChain()
ch.Add(source.NewNextReaderSource(from))
timingOp, _, dur := timing.NewTimingOp()
ch.Add(timingOp)
ch.Add(compress.NewSnappyEncodeOp())
ch.Add(sink.NewWriterSink(to))

ch.Start()

log.Printf("RES: Compress Snappy.ttRatio %v", float64(to.ByteSize())/float64(from.ByteSize()))
log.Printf("RES: Compress Snappy.ttBuffered Items: %dtItem: %vttook: %vtrate: %dtsize: %Etsize/item: %E", to.Len(), *counter, *dur, int(    float64(*counter)/(*dur).Seconds()), float64(to.ByteSize()), float64(to.ByteSize())/float64(*counter))

Les opérateurs sont les principaux composants d'une chaîne. Ils traitent les tuples pour produire des résultats. Les sources sont des opérateurs sans sortie. Les puits sont des opérateurs sans intervention. Les opérateurs implémentent stream.Operator. Si cela prend une entrée, implémente stream.In; s'il produit une sortie, implémente stream.Out.

Les mappeurs offrent un moyen simple d'implémenter des opérateurs. mapper.NewOp() prend une fonction de la forme func(input stream.Object, out Outputer) qui traite l'entrée et la transmet à l'objet Outputr. Les mappeurs sont automatiquement parallélisés. Les générateurs permettent de fournir aux mappeurs un stockage local par thread via des fermetures. Vous pouvez également donner aux mappeurs des fonctionnalités spéciales une fois qu'ils ont fini de traiter le dernier tuple.

Vous pouvez également diviser les données d'une chaîne en d'autres chaînes. stream.Fanout prend les entrées et les copie sur N autres chaînes. Le distributeur prend l'entrée et la place sur 1 des N chaînes selon une fonction de mappage.

Les chaînes peuvent être commandées ou non. Les chaînes ordonnées préservent l'ordre des tuples de l'entrée à la sortie (bien que les opérateurs utilisent toujours le parallélisme).

Compilation : allez construire

Tests : allez tester