Est-il possible de vérifier en Java si le CPU est hyper threading?

j'aimerais connaître le nombre optimal de threads que je peux lancer. Normalement, cela équivaut à Runtime.getRuntime().availableProcessors().

cependant, le nombre retourné est deux fois plus élevé sur un processeur supportant un filetage hyper. Maintenant, pour certaines tâches hyper threading est bon, mais pour d'autres, il ne fait rien. Dans mon cas, je soupçonne, il ne fait rien et je souhaite donc savoir si je dois diviser le nombre retourné par Runtime.getRuntime().availableProcessors() en deux.

pour cela je dois déduire si le CPU est hyper filetage. Conséquent ma question - comment puis-je le faire en Java?

Merci.

EDIT

OK, j'ai comparé mon code. Voici mon environnement:

• Lenovo ThinkPad W510 (i.e. i7 CPU with 4 core and hyperthreading), 16G de RAM
• Windows 7
• 84 fichiers CSV zippés avec des tailles de zippés allant de 105M à 16M
• tous les fichiers sont lus un par un dans le thread principal - pas d'accès multithreading HD.
• chaque ligne de fichier CSV contient des données, qui sont analysées et un test rapide sans contexte détermine si la ligne est pertinente.
• chaque ligne pertinente contient deux doubles (représentant la longitude et la latitude, pour les curieux), qui sont forcés en un seul Long, qui est ensuite stocké dans un hachage partagée ensemble.

ainsi les fils d'ouvrier ne lisent rien de la HD, mais ils s'occupent avec le dézipping et l'analyse du contenu (à l'aide de la opencsv bibliothèque).

ci-dessous se trouve le code, avec les détails ennuyeux:

public void work(File dir) throws IOException, InterruptedException {
  Set<Long> allCoordinates = Collections.newSetFromMap(new ConcurrentHashMap<Long, Boolean>());
  int n = 6;
  // NO WAITING QUEUE !
  ThreadPoolExecutor exec = new ThreadPoolExecutor(n, n, 0L, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
  StopWatch sw1 = new StopWatch();
  StopWatch sw2 = new StopWatch();
  sw1.start();
  sw2.start();
  sw2.suspend();
  for (WorkItem wi : m_workItems) {
    for (File file : dir.listFiles(wi.fileNameFilter)) {
      MyTask task;
      try {
        sw2.resume();
        // The only reading from the HD occurs here:
        task = new MyTask(file, m_coordinateCollector, allCoordinates, wi.headerClass, wi.rowClass);
        sw2.suspend();
      } catch (IOException exc) {
        System.err.println(String.format("Failed to read %s - %s", file.getName(), exc.getMessage()));
        continue;
      }
      boolean retry = true;
      while (retry) {
        int count = exec.getActiveCount();
        try {
          // Fails if the maximum of the worker threads was created and all are busy.
          // This prevents us from loading all the files in memory and getting the OOM exception.
          exec.submit(task);
          retry = false;
        } catch (RejectedExecutionException exc) {
          // Wait for any worker thread to finish
          while (exec.getActiveCount() == count) {
            Thread.sleep(100);
          }
        }
      }
    }
  }
  exec.shutdown();
  exec.awaitTermination(1, TimeUnit.HOURS);
  sw1.stop();
  sw2.stop();
  System.out.println(String.format("Max concurrent threads = %d", n));
  System.out.println(String.format("Total file count = %d", m_stats.getFileCount()));
  System.out.println(String.format("Total lines = %d", m_stats.getTotalLineCount()));
  System.out.println(String.format("Total good lines = %d", m_stats.getGoodLineCount()));
  System.out.println(String.format("Total coordinates = %d", allCoordinates.size()));
  System.out.println(String.format("Overall elapsed time = %d sec, excluding I/O = %d sec", sw1.getTime() / 1000, (sw1.getTime() - sw2.getTime()) / 1000));
}

public class MyTask<H extends CsvFileHeader, R extends CsvFileRow<H>> implements Runnable {
  private final byte[] m_buffer;
  private final String m_name;
  private final CoordinateCollector m_coordinateCollector;
  private final Set<Long> m_allCoordinates;
  private final Class<H> m_headerClass;
  private final Class<R> m_rowClass;

  public MyTask(File file, CoordinateCollector coordinateCollector, Set<Long> allCoordinates,
                Class<H> headerClass, Class<R> rowClass) throws IOException {
    m_coordinateCollector = coordinateCollector;
    m_allCoordinates = allCoordinates;
    m_headerClass = headerClass;
    m_rowClass = rowClass;
    m_name = file.getName();
    m_buffer = Files.toByteArray(file);
  }

  @Override
  public void run() {
    try {
      m_coordinateCollector.collect(m_name, m_buffer, m_allCoordinates, m_headerClass, m_rowClass);
    } catch (IOException e) {
      e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
    }
  }
}

Veuillez trouver ci-dessous les résultats (j'ai légèrement changé la sortie d'omettre de le répéter):

Max concurrent threads = 4
Total file count = 84
Total lines = 56395333
Total good lines = 35119231
Total coordinates = 987045
Overall elapsed time = 274 sec, excluding I/O = 266 sec

Max concurrent threads = 6
Overall elapsed time = 218 sec, excluding I/O = 209 sec

Max concurrent threads = 7
Overall elapsed time = 209 sec, excluding I/O = 199 sec

Max concurrent threads = 8
Overall elapsed time = 201 sec, excluding I/O = 192 sec

Max concurrent threads = 9
Overall elapsed time = 198 sec, excluding I/O = 186 sec

vous êtes libre de tirer vos propres conclusions, mais la mienne est que l'hyperthreading améliore la performance dans mon cas concret. En outre, avoir 6 fils ouvriers semble être le bon choix pour cette tâche et ma machine.