Devops for Growth
107.7K views | +0 today
Follow
Devops for Growth
For Product Owners/Product Managers and Scrum Teams: Growth Hacking, Devops, Agile, Lean for IT, Lean Startup, customer centric, software quality...
Curated by Mickael Ruau
Your new post is loading...
Your new post is loading...

Popular Tags

Current selected tags: 'performance', 'cloud'. Clear
Scooped by Mickael Ruau
Scoop.it!

Numbers Everyone Should Know

Numbers Everyone Should Know | Devops for Growth | Scoop.it

 

Operation Time (nsec) L1 cache reference 0.5 Branch mispredict 5 L2 cache reference 7 Mutex lock/unlock 25 Main memory reference 100 Compress 1KB bytes with Zippy 3,000 Send 2K bytes over 1 Gbps network 20,000 Read 1MB sequentially from memory 250,000 Roundtrip within same datacenter 500,000 Disk seek 10,000,000 Read 1MB sequentially from disk 20,000,000 Send packet CA -> Netherlands -> CA 150,000,000

 

Some useful figures that aren’t in Dean’s data can be found in this article comparing NetBSD 2.0 and FreeBSD 5.3 from 2005. Approximating those figures, we get:

Operation Time (nsec) System call overhead 400 Context switch between processes 3000 fork() (statically-linked binary) 70,000 fork() (dynamically-linked binary) 160,000
Mickael Ruau's insight:

Update: This recent blog post examines the question of system call and context switch overhead in more detail. His figures suggest the best-case system call overhead is now only ~60 nsec (for Linux on Nehelem), and that context switches cost about 30 microseconds (30,000 nsec) — when you account for the cost of flushing CPU caches, that is probably pretty reasonable.

In comparison, John Ousterhout’s RAMCloud project aims to provide end-to-end roundtrips for a key-value store in the same datacenter within “5-10 microseconds,” which would represent about a 100x improvement over the 500 microsecond latency suggested above.

The keynote slides are worth a glance: Dean talks about the design of “Spanner”, a next-generation version of BigTable he is building at Google. See also James Hamilton’s notes on the keynote, and Greg Linden’s commentary.

No comment yet.
Scooped by Mickael Ruau
Scoop.it!

Attack of the Killer Microseconds - [Site WWW de Laurent Bloch]

Le dernier numéro des Communications of the ACM [1] (CACM) contient un article intitulé Attack of the Killer Microseconds écrit par des ingénieurs de Google, dont David Patterson, qui fut dans des vies antérieures professeur à Berkeley, architecte principal des processeurs SPARC de Sun Microsystems et co-auteur avec John Hennessy (architecte principal des processeurs MIPS et actuel président de l’université Stanford) du manuel de référence sur l’architecture des ordinateurs (pour dire qu’il ne s’agit pas d’élucubrations d’amateurs).

 

(...)

Ces problèmes de temps de latence pénalisants surgissent aujourd’hui parce que des événements qui étaient relativement rares dans les traitements d’hier (appel de procédures à distance, déplacement de machine virtuelle par exemple) sont désormais au cœur des architectures de traitement de données. Tant que ces événements étaient rares, les architectes de système adoptaient des solutions simples, telles que, simplement, attendre la fin de l’action, mais dès lors que ces événements sont fréquents la pénalité encourue devient de moins en moins supportable.

Pour alléger ces pénalités, nos auteurs suggèrent de concevoir à nouveaux frais des optimisations pour les mécanismes de bas niveau, tels que contention de verrou et synchronisation. Les spécialistes du calcul à haute performance (HPC) se sont confrontés à ces problèmes depuis longtemps, mais les solutions qu’ils ont adoptées ne répondent pas forcément très bien aux questions actuelles, parce qu’ils travaillaient généralement dans un contexte où les contraintes économiques étaient faibles, ce qui n’est pas le cas des grands centres de données d’aujourd’hui.

De surcroît, les logiciels déployés par les grands opérateurs tels que Google et Amazon évoluent rapidement, ce qui impose des méthodes de génie logiciel rigoureuses et simplificatrices, impératif ignoré du monde HPC.

Des solutions doivent également être cherchées du côté des processus légers, du parallélisme à grain fin, de la gestion plus efficace des files d’attente, etc. Je ne puis mieux faire que vous recommander la lecture de cet article.

Mickael Ruau's insight:

 

Nos auteurs donnent les ordres de grandeur suivants pour 2017 :

En nanosecondes : En microsecondes : En millisecondes : Accès registre : 1ns-5ns réseau local : O(1µs) Accès disque : O(10ms) Accès cache : 4ns-30ns Mémoire non-volatile : O(1µs) Clé USB : O(1ms) Accès mémoire : 100ns Mémoire flash rapide : O(10µs) Internet : O(10ms)

Les efforts les plus importants (ils se chiffrent en milliards d’euros de recherche-développement) ont porté sur les actions de la première et de la troisième colonne, même si l’on peut noter la relative stagnation des performances des disques durs.

En d’autres termes, voici le nombre d’instructions qu’un processeur moderne peut effectuer pendant les opérations de lecture-écriture suivantes :

Mémoire flash 225 000 instructions = O(100µs) Flash rapide 20 000 instructions = O(10µs) Mémoire NVM 2 000 instructions = O(1µs) Mémoire centrale 500 instructions = O(100ns)
No comment yet.