Comment détecter SSD sous Mac OS X?

Question

Existe-t-il un moyen fiable, rapide et déterministe (par exemple et non un test de performances) pour vérifier si le lecteur système Mac OS X est sous tension?

Existe-t-il un autre indicateur de la façon dont le disque gère l'accès parallèle? J'essaie d'ajuster le nombre de threads que mon programme va utiliser pour les opérations liées au disque.

Je ne suis pas intéressé par la vitesse brute ou le temps de recherche, seul le type d'accès (série ou parallèle) est plus rapide pour le lecteur. Je ne m'attends pas à ce que les utilisateurs de mon programme utilisent iSCSI ou RAID. SSD est mon objectif, tout le reste est agréable à avoir.

Device Characteristics de IOAHCIBlockStorageDevice contient cette information. Comment puis-je le lire par programme?

---

Jusqu'à présent, j'ai compris il va comme ceci: (Voici pseudocode)

match = IOBSDNameMatching(kIOMasterPortDefault,0,"disk0s2"); 
IOServiceGetMatchingServices(kIOMasterPortDefault, match, &iterator); 
while(entry = IOIteratorNext(iterator)) { 
    do { 
    entry = IORegistryEntryGetParentEntry(nextMedia, kIOServicePlane, &entry); 
    dict = IORegistryEntryCreateCFProperty(nextMedia, 
      CFSTR(kIOPropertyDeviceCharacteristicsKey), kCFAllocatorDefault, 0); 
    [dict objectForKey:CFSTR(kIOPropertyMediumTypeKey)]; 
    } 
    while(!dict && entry); 
} 

---

Edit: Here's complete source code. J'ai vérifié qu'il fonctionne avec Intel SSD et OCZ Vertex.

Answer 1

Si vous essayez d'obtenir ce genre d'information, vous êtes mieux de deviner que c'est IOKit.

Vous pouvez essayer certains de ses fonctionnalités à l'aide de l'outil de ligne de commande de ioreg ou IORegistryExplorer.

---

Voici un code qui pourrait vous aider. Il récupère tous les disques durs qui ne sont pas un RAID et ne sont pas des partitions. Ce n'est pas ce que vous voulez, mais cela pourrait vous aider à démarrer.

#import "TWDevice.h" 

#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 
#include <fcntl.h> 
#include <sys/ioctl.h> 
#include <errno.h> 
#include <paths.h> 
#include <sys/param.h> 
#include <IOKit/IOKitLib.h> 
#include <IOKit/IOBSD.h> 
#include <IOKit/storage/IOMedia.h> 
#include <CoreFoundation/CoreFoundation.h> 
#include <IOKit/Kext/KextManager.h> 


@implementation TWDevice 

@synthesize name, devicePath, size, blockSize, writable, icon; 

+ (NSArray *)allDevices { 
    // create matching dictionary 
    CFMutableDictionaryRef classesToMatch; 
    classesToMatch = IOServiceMatching(kIOMediaClass); 
    if (classesToMatch == NULL) { 
     [NSException raise:@"TWError" format:@"Classes to match could not be created"]; 
    } 

    // get iterator of matching services 
    io_iterator_t mediaIterator; 
    kern_return_t kernResult; 
    kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, 
                     classesToMatch, 
                     &mediaIterator); 

    if (kernResult != KERN_SUCCESS) { 
     [NSException raise:@"TWError" format:@"Matching services did not succed."]; 
    } 

    // iterate over all found medias 
    io_object_t nextMedia; 
    NSMutableArray *detectedDevices = [NSMutableArray array]; 
    while (nextMedia = IOIteratorNext(mediaIterator)) { 
     NSMutableDictionary *properties; 
     kernResult = IORegistryEntryCreateCFProperties(nextMedia, 
                        (CFMutableDictionaryRef *)&properties, 
                        kCFAllocatorDefault, 0); 

     if (kernResult != KERN_SUCCESS) { 
      [NSException raise:@"TWError" format:@"Getting properties threw error."]; 
     } 

     // is it a whole device or just a partition? 
     if ([[properties valueForKey:@"Whole"] boolValue] && 
      ![[properties valueForKey:@"RAID"] boolValue]) { 
      TWDevice *device = [[[TWDevice alloc] init] autorelease]; 

      device.devicePath = [NSString stringWithFormat:@"%sr%@", _PATH_DEV, [properties valueForKey:@"BSD Name"]]; 
      device.blockSize = [[properties valueForKey:@"Preferred Block Size"] unsignedLongLongValue]; 
      device.writable = [[properties valueForKey:@"Writable"] boolValue]; 
      device.size = [[properties valueForKey:@"Size"] unsignedLongLongValue]; 

      io_name_t name; 
      IORegistryEntryGetName(nextMedia, name); 
      device.name = [NSString stringWithCString:name encoding:NSASCIIStringEncoding]; 

      … 

      [detectedDevices addObject:device]; 
     } 

     // tidy up 
     IOObjectRelease(nextMedia); 
     CFRelease(properties); 
    } 
    IOObjectRelease(mediaIterator); 

    return detectedDevices; 
} 

@end 

Answer 2

En fait, je pense que vous devriez aller sur la voie de l'analyse comparative, car il répond plus précisément à votre question - vous n'avez pas vraiment besoin que le disque soit vraiment un disque SSD. Que faire si l'utilisateur utilise une configuration RAID rapide ou une baie Fibre Channel ou utilise iSCSI?

Il suffit de lire un tas de secteurs aléatoires du sous-jacent/dev/DiskX et si elle répond à vos besoins, vous pouvez le traiter comme un « rapide » drive

Answer 3

Le nombre de threads? 1 va submerger n'importe quel disque, SSD, RAID ou pas. Le disque est lent, le processeur est rapide. Le système d'exploitation va réorganiser vos demandes de disque de toute façon (ou du moins il devrait) pour obtenir le moins de mouvements de la tête.