8
votes

Runtime.AvailableProcesseurs: qu'est-ce qu'il va revenir?

Le Javadoc pour Runtime.AvailableProcesseurs () Dans Java 1.6 est délicieusement non spécifique. Est-ce que cela cherche juste à la configuration matérielle, ou aussi à la charge? Est-ce assez intelligent d'éviter d'être dupe par hyperthreading? Respecte-t-il un ensemble limité de processeurs via la commande TaskSet Linux ?

Je peux ajouter une date de données de la mienne: Sur un ordinateur ici avec 12 cœurs et hyperthreading, Runtime.AvailableProcesseurs () renvoie actuellement 24 ans, ce qui n'est pas un bon numéro à utiliser pour décider du nombre de fils pour essayer de fonctionner. La machine n'était clairement pas morte-ralenti, elle n'aurait donc pas non plus d'examiner la charge de manière efficace.


                        
                        
                            
                                                                    java
                                                            
                        
                                                    
                            
                            
                                2 commentaires
                                
                                                                            Le fait que la documentation mentionne explicitement que sa valeur peut changer, il est peu probable qu'il ne s'agit que de la configuration matérielle. Je suppose que cela renvoie le nombre de threads Java pouvant être exécutés en parallèle.
                                        
                                                                            Oracle / Sun a écrit «optimiste» Doc dans le passé. Je suis d'accord sur l'implication, mais je suis en train de pêcher des faits.



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     AFAIK, cela vous donne toujours le nombre total de CPU disponibles, même ceux qui n'étaient pas disponibles pour la planification. J'ai une bibliothèque qui utilise ce fait pour trouver des processeurs réservés. J'ai lu la / proc / cpuinfo et l'affinité de fil par défaut du processus pour déterminer ce qui est disponible.                                 

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Selon  Sun Bug 6673124 : 

   Le code pour  actif_processor_count  code>, utilisé par  runtime.AvailableProcesseurs ()  code> est comme suit:  p>

int os::active_processor_count() {
  int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
  pid_t pid = getpid();
  psetid_t pset = PS_NONE;
  // Are we running in a processor set?
  if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
    if (pset != PS_NONE) {
      uint_t pset_cpus;
      // Query number of cpus in processor set
      if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
    assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
    _processors_online = pset_cpus;
    return pset_cpus;
      }
    }
  }
  // Otherwise return number of online cpus
  return online_cpus;
}

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    8
 votes
                                
                            
                            
                                
                                     sur Windows,  getSysteminfo  est utilisé et  DwnumberofProcesseurs  code> à partir du renvoi  System_info  CODE> Structure. 
 Ceci peut être vu depuis  Void OS :: Win32 :: initialize_system_info ()  et  int Os :: actif_processor_count ()  code> dans  OS_Windows.cpp  code> du code source OpenJDK.  p> 
  DwnumberofProcesseurs  code> De la documentation MSDN indique qu'il rapporte «le nombre de transformateurs logiques du groupe actuel», ce qui signifie que l'hyperthreading augmentera le nombre de processeurs rapportés.  P> 
 sur Linux,  OS :: actif_processor_count ()  code> utilise  SYSCONF :  P> 
int os::active_processor_count() {
  // Linux doesn't yet have a (official) notion of processor sets,
  // so just return the number of online processors.
  int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
  assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
  return online_cpus;
}

                                

                                                                    
                                    
                                    
                                        0 commentaires