Bonjour
Je possède deux ordis, un desktop avec un processeur Intel Core I7 7700 X 8 et un portable avec un processeur Intel Core I5 10210 U x 8;
Exactement le même calcul prend près de 5 fois plus de temps sur le desktop que sur le portable (autour de 5 secondes alors que le portable le fait en 1 seconde).
Est-ce un problème de processeur ou un problème matériel ? (perso je n'y crois pas, il n'y pas d'écriture disque pendant les calculs.)
Existe -t-il des processeurs, pas trop chers évidemment, dédiés au calculs "scientifiques" ?
Merci

normalement ton 7700 devrait etre un poil plus perfo je pense
 
Ca depend de ton calcul, de la vitesse du disque si tu dois lire des données ( SSD / HDD ) , du temps de chargment des librairies utilisée pour ton calcul, de ta carte graphique qui pourrait aider a des calculs en fonction du logiciel que tu utilises, des version de librairie de calcul, de la ram que tu as de dispo sur chaque pc , et de ce qui tourne au moment du lancement de ton pc, de l'état de ton windows , de l'espace dispo ....
 
Je miserai plus sur une investigation logicielle dans un premier temps, je comparerai l'état des ressources de la machine au moment du lancement du calcul.
 
Avec les specs des machines, et les ressources libres au lancement du calcul et le type de calcul que tu veux lancer on pourrait peut etre avoir des avis. La c'est un peu vague *
 
Fais toi un bon tableau comparatif

Merci de tes conseils, je vais voir ce que je peux faire.
Déjà mon programme est écrit en Rust, manipule des vecteurs et trie a chaque tour plus de 15000 listes. Il tourne sous VS Code et sous Fédora 43, 64 bits sur les deux ordis.  
Il ne lit ou écrit aucune données sur le disque, sauf 1 fois toutes les 10 minutes dans le meilleurs des cas.
[EDIT] je n'avais pas vu le message de celestins
Dommage pour super-pi, c'est du Windows, et il n'est pas installé sur les ordis

Petite réponses IA
 
Pour le développement en Rust, le choix entre un Intel Core i7-7700 (processeur de bureau) et un Intel Core i5-10210U (processeur d'ordinateur portable) dépendra de si vous privilégiez la vitesse de compilation brute ou la modernité de l'architecture.
Voici le comparatif détaillé pour votre usage :
1. Performance de compilation (Le point critique pour Rust)
Le compilateur Rust (rustc) est particulièrement gourmand. Il tire profit à la fois de la performance monocœur (pour les phases finales de liaison/LLVM) et du multicœur (pour compiler les différentes "crates" en parallèle).
 * Intel Core i7-7700 (Desktop) : Malgré son âge, il gagne sur la stabilité des fréquences. Avec un TDP de 65W, il peut maintenir sa fréquence turbo sur tous les cœurs pendant toute la durée d'une compilation longue sans surchauffer ("thermal throttling" ).
 * Intel Core i5-10210U (Laptop) : C'est un processeur basse consommation (15W). S'il peut monter très haut en pointe (4.2 GHz), il redescendra très vite en fréquence dès que la compilation dépassera 30 secondes pour éviter la chauffe.
| Caractéristique | i7-7700 (Desktop) | i5-10210U (Mobile) | Gagnant |
|---|---|---|---|
| Cœurs / Threads | 4 / 8 | 4 / 8 | Égalité |
| Fréquence de base | 3.6 GHz | 1.6 GHz | i7-7700 |
| Fréquence Turbo | 4.2 GHz | 4.2 GHz | Égalité |
| Cache L3 | 8 MB | 6 MB | i7-7700 |
| TDP (Puissance) | 65W | 15W | i7-7700 (plus stable) |
2. Pourquoi le i7-7700 est généralement meilleur ici ?
Même si le i5-10210U est plus récent de trois générations, il est conçu pour la mobilité et l'économie d'énergie. Pour Rust :
 * Le cache L3 : Le i7 dispose de 2 MB de cache supplémentaire, ce qui aide significativement lors de la manipulation de l'arbre de syntaxe complexe de Rust.
 * La RAM : Sur un i7-7700 (PC fixe), vous aurez souvent accès à de la RAM plus rapide ou en plus grande quantité (crucial pour les gros projets Rust).
 * Endurance : Compiler un projet comme tokio ou une interface graphique en Rust fait chauffer le CPU. Le i7-7700 tiendra la charge sans ralentir, contrairement au i5-10210U.
En résumé
 * Choisissez le i7-7700 si vous avez le choix entre deux machines fixes ou si vous cherchez la machine de travail la plus "solide" pour coder.
 * Choisissez le i5-10210U uniquement si vous avez besoin de portabilité (ordinateur portable) et que vous acceptez des temps de compilation légèrement plus longs et instables.
Conseil d'ami : Quel que soit votre choix, assurez-vous d'avoir au moins 16 Go de RAM et un SSD NVMe. Rust écrit énormément de fichiers temporaires dans le dossier target/, et un disque lent bridera votre processeur plus que n'importe quoi d'autre.
Souhaitez-vous que je vous aide à optimiser votre configuration cargo pour accélérer vos compilations sur l'un de ces processeurs ?
 
C'est une situation surprenante sur le papier, mais elle s'explique souvent par des différences de configuration logicielle ou matérielle sous-jacentes, car un i7-7700 ne devrait pas être "5 fois" plus lent qu'un processeur basse consommation comme le 10210U.
Voici les pistes prioritaires à vérifier sous Fedora pour comprendre ce goulet d'étranglement :
1. Le mode de compilation (Le piège classique)
C'est la cause n°1 de lenteur en Rust. Vérifiez comment vous lancez votre programme :
 * Debug (par défaut) : cargo run ou cargo build. Le code n'est pas optimisé, les vérifications de débordement sont actives.
 * Release (Optimisé) : cargo run --release ou cargo build --release.
> Hypothèse : Il est possible que sur l'une des machines vous testiez le binaire release et sur l'autre le binaire debug. La différence de performance peut aller de 1 à 10.
>  
2. Le Governor de mise à l'échelle (CPU Frequency)
Sur Fedora, le gestionnaire d'énergie peut brider le i7-7700, surtout s'il est en mode "Power Save".
Vérifiez le mode actif avec cette commande :
powerprofilesctl get
 
Si vous voyez power-saver, passez en mode performance :
powerprofilesctl set performance
 
3. Architecture cible et instructions vectorielles (AVX/AVX2)
Le i5-10210U est plus récent. Si votre code utilise des bibliothèques de calcul intensif (simd, compression, crypto), il profite peut-être d'optimisations que le compilateur n'active pas par défaut sur le i7-7700.
Essayez de compiler avec les optimisations spécifiques à votre processeur local :
RUSTFLAGS="-C target-cpu=native" cargo build --release
 
4. Différences matérielles critiques
Même si le processeur est le cerveau, Rust est très sensible au reste du corps :
 * La RAM (Single vs Dual Channel) : Si votre i7-7700 n'a qu'une seule barrette de RAM (Single Channel), la bande passante mémoire est divisée par deux. Rust est très gourmand en accès mémoire.
 * Le SSD vs HDD : Si le dossier target/ de votre projet est sur un disque dur mécanique (HDD) sur le 7700, les performances s'effondrent à cause des entrées/sorties constantes.
5. Comparaison des fréquences réelles
Installez htop ou btop et lancez votre code. Regardez la fréquence réelle (GHz) affichée :
 * Le i7-7700 chauffe-t-il ? Si la pâte thermique est vieille, il peut descendre à 800 MHz pour ne pas brûler, ce qui expliquerait la lenteur extrême.
Pour isoler le problème, pourriez-vous me dire :
 * Utilisez-vous bien le flag --release sur les deux ?
 * Quelle est la nature de votre code (Calcul pur, beaucoup d'accès disque, ou réseau) ?
 * Avez-vous vérifié les températures avec sensors ?
Souhaitez-vous que je vous donne une commande pour benchmarker précisément la vitesse de calcul brute (sans accès disque) sur vos deux machines ?

Merci IA (et miksair ... ) pour les réponses.
La compilation n'est pas un problème, c'est l’exécution qui m'en pose un.
Sur les deux ordi le profil powerprofile est "balanced", 16 Go de RAM et des SSD sur les deux.
Les deux programmes sont compilés en Debug, effectivement je pourrais tenter en release.
Pour le reste, je vais étudier tout ça.
J'ai trouve le source de super_pi, je vais compiler et tester.

Apres y a une section programmation tu auras peut etre plus de réponses  
 
Ceci dit le problème matériel n’est peut etre pas a exclure,  mais je miserai sur une meilleure optimisation des lib a utiliser de nouvelles instructions processeur plus efficaces

Bon le problème est résolu, c'est moi qui n'ai pas fait attention à un "petit" détail.
Mon programme travaille sur des listes de longueur 40 à 70 éléments.
Je lance le programme en paramétrant le début de l'étude de ces listes à partir d'un certain rang qui peut varier en fonction de ce que je recherche (travail d'optimisation).
Il se trouve que sur l'ordi je commençais le travail plutôt en début de ces listes alors que sur le portable, c'était plutôt en fin ! Comme je le disais le programme tourne avec plus de 15000 listes, ça explique très bien la différence de temps d'exécution.
Désolé de vous avoir fait perdre du temps avec mes questions.
Merci à ceux qui m'ont répondu, j'ai appris des choses intéressantes.

Alors ca va plus vite sur lequel au final ?

Bon, j'ai recompilé le programme sur les deux machines en mode optimise (opt-level = 3 pour les connaisseurs), et ça fonctionne à la même vitesse avec les mêmes paramètres de lancement, ça me rassure  

Du coup le problème etait entre le clavier et la machine, comme souvent

Exactement