À grain grossier vs à grain fin

Quelle est la différence entre à gros grains et à grains fins?

J'ai recherché ces termes sur Google, mais je n'ai pas trouvé ce qu'ils signifient.

Depuis Wikipedia (granularité) :

La granularité est la mesure dans laquelle un système est décomposé en petites parties, soit le système lui-même, soit sa description ou son observation. C'est la mesure dans laquelle une entité plus grande est subdivisée. Par exemple, une cour divisée en pouces a une granularité plus fine qu'une cour divisée en pieds.

Les systèmes à gros grains comportent moins de composants plus gros que les systèmes à grains fins; une description grossière d'un système concerne de grands sous-composants tandis qu'une description fine concerne des composants plus petits dont les plus grands sont composés.

En termes simples

• À gros grains - composants plus gros que les grands sous-composants à grains fins. Enroule simplement un ou plusieurs services à grains fins ensemble dans une opération plus grossière.
• À grain fin - composants plus petits dont les plus grands sont composés, service de niveau inférieur

Il est préférable d'avoir des opérations de service plus grossières, qui sont composées d'opérations à grains fins

À gros grains: quelques objets contiennent beaucoup de données connexes, c'est pourquoi les services ont une portée plus large en termes de fonctionnalités. Exemple: un seul objet «Compte» contient le nom du client, l'adresse, le solde du compte, la date d'ouverture, la date de la dernière modification, etc. Ainsi: Complexité de conception accrue, nombre de cellules plus petit pour diverses opérations

Précision: plus d'objets contenant chacun moins de données, c'est pourquoi les services ont une portée plus étroite en termes de fonctionnalités. Exemple: un objet Account détient le solde, un objet Customer contient le nom et l'adresse, un objet AccountOpenings contient la date d'ouverture, etc. Ainsi: Diminution de la complexité de conception, plus grand nombre de cellules pour diverses opérations de service. Ce sont des relations définies entre ces objets.

Une autre manière de comprendre serait de penser en termes de communication entre processus et threads. Les processus communiquent à l'aide de mécanismes de communication à gros grains tels que les sockets, les gestionnaires de signaux, la mémoire partagée, les sémaphores et les fichiers. Les threads, quant à eux, ont accès à un espace mémoire partagé appartenant à un processus, ce qui leur permet d'appliquer des mécanismes de communication plus fins.

Source: la concurrence Java en pratique

En terme de jeu de données comme un fichier texte, à grain grossier signifie que nous pouvons transformer l'ensemble de données, mais pas un élément individuel sur l'ensemble de données, tandis que le grain fin signifie que nous pouvons transformer un élément individuel sur l'ensemble de données.

Dans le cadre des services:

http://en.wikipedia.org/wiki/Service_Granularity_Principle

Par définition, une opération de service à gros grains a une portée plus large qu'un service à grains fins, bien que les termes soient relatifs. Le premier nécessite généralement une complexité de conception accrue, mais peut réduire le nombre d'appels requis pour effectuer une tâche.

Une interface de service à grain fin est à peu près la même chose qu'une interface bavarde.

Le grain grossier et le grain fin pensent tous deux à optimiser un certain nombre de services. Mais la différence réside dans le niveau. J'aime expliquer avec un exemple, vous comprendrez facilement.

Fine-grained : Par exemple, j'ai 100 services comme findbyId, findbyCategry, findbyName ...... ainsi de suite. Au lieu de ces nombreux services pourquoi nous ne pouvons pas fournir de recherche (id, catégorie, nom .... etc.). Ainsi, nous pouvons réduire les services. Ceci n'est qu'un exemple, mais l'objectif est de savoir comment optimiser le nombre de services.

À gros grains : par exemple, j'ai 100 clients, chaque client a son propre ensemble de 100 services. Je dois donc fournir 100 * 100 services au total. C'est très difficile. Au lieu de cela, ce que je fais, c'est identifier tous les services communs qui s'appliquent à la plupart des clients comme un ensemble de services et restant séparément. Par exemple, dans 100 services, 50 services sont courants. Je dois donc gérer 100 * 50 + 50 uniquement.

La granularité à gros grains ne signifie pas toujours des composants plus gros, si vous utilisez littéralement le sens du mot grossier, cela signifie dur ou non approprié. Par exemple, dans la gestion de projets logiciels, si vous décomposez un petit système en quelques composants, qui sont de taille égale, mais dont la complexité et les fonctionnalités varient, cela peut conduire à une granularité grossière. À l'inverse, pour une ventilation fine, vous diviseriez les composants en fonction de leur cohésion des fonctionnalités fournies par chaque composant.

à gros grains et à grains fins. Ces deux modes définissent la manière dont les cœurs sont partagés entre plusieurs tâches Spark. Comme son nom l'indique, le mode à grain fin est responsable du partage des cœurs à un niveau plus granulaire. Le mode affiné a été abandonné par Spark et sera bientôt supprimé.

Les services Corse-grained fournissent des fonctionnalités plus larges par rapport aux services fins. Selon le domaine d'activité, un service unique peut être créé pour servir une seule unité commerciale ou plusieurs services spécialisés à granularité fine peuvent être créés si les sous-unités sont largement indépendantes les unes des autres. Le service à gros grains peut devenir plus difficile, peut être moins adaptable au changement en raison de sa taille, tandis qu'un service à grain fin peut introduire une complexité supplémentaire dans la gestion de plusieurs services.

Dans les termes de POS (Part of Speech) Tag,

• Fine-grained - Utilisation des balises Penn Treebank qui ont 36 balises différentes
• À grain grossier - Utilisation de balises universelles comportant 12 balises différentes