Mon programme supposément déterministe produit l'un de quelques sorties légèrement différentes sur différentes pistes. L'entrée, le compilateur et l'ordinateur sont immuables. Je ne suis pas sûr que la sortie est juste parce que cela semble toujours raisonnable.
Outre un appel erroné à Rand (), comment cela pourrait-il être possible?
12 Réponses :
Cela pourrait être:
de plusieurs manières:
Nous pouvons sûrement faire plus d'hypothèses, mais si vous voulez avoir une aide significative, il serait peut-être bon que vous publiez les parties pertinentes de votre code: -)
Oui; Nous avons besoin de code! Bien entendu, tous ces facteurs ainsi que les erreurs décimales et les pseudo-aléomisations sont techniquement déterministes car ils fonctionnent sur une machine déterministe. Ils ne semblent tout simplement pas déterministes pour nous lorsque nous ne pouvons pas suivre ou comprendre les intrants et les millions d'états progressifs de notre programme dans le contexte d'un système de partage de temps de partage de temps moins personnellement contrôlé. C'est pourquoi la théorie et la science informatique sont toujours importantes d'enseigner aux côtés des compétences de programmation des noix et des boulons.
J'aurais dû préciser que je voulais seulement une liste de possibilités courantes, ce que j'ai eu. Merci.
BTW, des variables non initialisées sont efficacement déterministes que si vous attachez un débogueur; Cependant, ils sont déterministes de la même manière que la corruption du tas à filetage unique est déterministe, ce qui n'est pas la déterministe que vous voulez.
Sans voir du code (indice d'indice), le meilleur que je puisse penser serait à la recherche d'un motif. Peut-être quelque chose de date-heure spécifique.
Aussi, essayez de chercher des conditions de course. Qui peut sembler non déterministe.
Si votre sortie dépend d'une adresse allouée sur le tas: pour chaque exécution, le malloc () peut renvoyer une adresse virtuelle différente - sans parler null au cas où l'allocation a échoué. .
Bonne prise. Heap / Stack Address Randomization est une jolie caractéristique standard de nos jours. Cela aurait un effet si les pointeurs seraient utilisés de clés quelque part. J'ai utilisé cela à quelques reprises pour faire le tri stable (si les clés sont égales, comparez les pointeurs).
Cependant, vous devriez être assez malchanceux / courir sur une mémoire très faible pour avoir une défaillance d'allocation.
La sortie dépendrait d'une adresse allouée sur le tas si des objets alloués en tas sont triés par leur adresse, par exemple si les pointeurs d'eux sont stockés dans un conteneur commandé comme un ensemble.
Utilisation de la valeur d'un pointeur au lieu de ce qu'il pointe de produire des résultats intéressants.
Outre un appel erroné à Rand ()
rand () est tout à fait déterministe tant que vous l'alignez la même graine initiale.
Dans les programmes qui n'interritent pas beaucoup avec le «monde extérieur», la popularienne source de non-déterminisme est la dépendance à la comparaison du pointeur. De temps en temps, vous pourriez le voir dans le code: lorsqu'une fonction de comparaison lexicographique s'étend sur des choses à comparer (tout est égal), il compare les les adresses d'objets comme dernier recours. Cela peut produire des commandes différentes si les objets sont attribués dans la mémoire dynamique, car les emplacements d'allocation réels peuvent différer de la plate-forme à la plate-forme et de la course à l'exécution.
Vous n'avez pas donné beaucoup d'informations. Cependant, comme une programmation en temps réel pour gagner la vie des culprises les plus susceptibles que je recherche lorsque de telles choses se produisent est la suivante:
Par exemple, un de ces ennuis que j'avais une fois descendu à la bibliothèque partagée qui ne soit pas aussi "partagé" que je pensais, et essayant d'utiliser une poignée d'un processus pour indexer une table aussi non assurée dans un deuxième processus. Selon la manière dont les choses ont commencé cela peuvent avoir ou non avoir causé des données importantes dans un troisième processus pour être détruit.
tout comportement non défini. C'est-à-dire: il faudra des centaines de pages pour expliquer chaque source possible d'altération de la production. Essayez de déboguer pour trouver où altération se produit ou lisez certaines spécifications C ++.
Si votre programme utilise Float / Double, il peut y avoir une différence dans le résultat s'il existe un commutateur de contexte sur une architecture.
sur x86, la FPU utilise la précision étendue pour le résultat intermédiaire, mais lors de l'enregistrement en mémoire (ce qui se produit lorsqu'un interrupteur de contexte est un processus ou un thread), une telle précision est perdue. Cela pourrait causer une faible divergence du résultat (nous avons détecté un tel problème dans notre programme). Une façon d'éviter que ce problème consiste à demander au compilateur de ne pas utiliser FPU mais SSE pour les opérations de points flottants.
http://www.network-theory.co.uk /docs/gccincintro/gccintro_70.html
Nous aurions besoin de voir du code avant de faire des spéculations sauvages.
Votre code contient-il quelque chose qui se passe dans la terre du comportement indéfini?
Qui a dit que les compilateurs sont déterministes?
@Ashleysbrain - Voir cette question Stackoverflow.com/Questtions/3053904/...
@Andy_vulhop - Il n'est jamais arrêté personne auparavant, mais je suis d'accord, nous serions plus productifs en regardant le code.
Êtes-vous sûr que ce n'est pas ses devoirs? Manque de code posté, plus votre commentaire que vous voulez seulement "une liste de possibilités courantes" semble un peu étrange.