Wie erkenne ich SSD in Mac OS X?

Question

Gibt es einen zuverlässigen, schnellen, deterministischen Weg (dh nicht Ein Benchmark), um zu prüfen, ob sich das System Drive Mac OS X einsetzt, ist ein Solid -State -Laufwerk?

Gibt es einen anderen Indikator, wie gut die Festplatte parallele Zugang abwickelt? Ich versuche, die Anzahl der Threads anzupassen, die mein Programm für diskontierte Operationen verwenden wird.

Ich interessiere mich nicht für rohe Geschwindigkeit oder Zeit für die Suche nach Zeit, nur welche Art von Zugriff - seriell oder parallel - ist für das Laufwerk schneller. Ich erwarte nicht, dass Benutzer meines Programms ISCSI oder RAID verwenden. SSD ist mein Fokus, alles andere ist schön.

Device Characteristics von IOAHCIBlockStorageDevice Enthält diese Informationen. Wie kann ich es programmatisch lesen?

---

Bisher habe ich herausgefunden, dass es so geht: (Folgendes ist 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); 
}

---

Bearbeiten: Hier ist der vollständige Quellcode. Ich habe verifiziert, dass es mit Intel SSD und OCZ Vertex funktioniert.

Answer 1

Wenn Sie versuchen, diese Art von Informationen zu erhalten, vermuten Sie es am besten.

Sie können einen Teil seiner Funktionalität mit dem ausprobieren Ioreg Befehlszeilenwerkzeug oder das IoregistryExplorer.

---

Hier ist ein Code, der Ihnen helfen könnte. Es holt alle Festplatten, die keine Raid sind und keine Partitionen sind. Das ist nicht das, was du willst, aber es könnte dir loslegen.

#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

Eigentlich denke ich, Sie sollten den Benchmarking -Weg gehen, weil sie Ihre Frage genauer beantwortet - Sie nicht Ja wirklich Wenn Sie sich darum kümmern, dass die Festplatte zufällig eine SSD ist, kümmern Sie sich nur darum, dass die Festplatte sehr schnell ist. Was ist, wenn der Benutzer ein schnelles RAID -Setup oder ein Fibre -Kanal -Array oder ISCSI verwendet?

Lesen Sie einfach eine Reihe von Zufallssektoren aus dem zugrunde liegenden /dev /diskx und wenn sie Ihren Anforderungen entspricht, können Sie sie als "schnelles" Laufwerk behandeln

Answer 3

Dies scheint nur für interne Laufwerke möglich zu sein. Ich konnte keinen Weg finden, mit IOKIT einen Samsung T5 External USB 3 SSD für seine SSD-Ness (noch einen Toshiba Canvio USB HDDD) abzufragen. Ich habe jedoch für das interne Laufwerk in meinem MBP geschafft.

Das Datenträger -Dienstprogramm glaubt auch nicht, dass der Samsung eine SSD ist, so dass ich der Ansicht ist, dass es möglicherweise keinen Weg gibt, außer die tatsächliche Leistung zu messen.

Answer 4

Die Anzahl der Threads? 1 wird jede Festplatte, SSD, Raid oder nicht überwältigen. Die Festplatte ist langsam, der Prozessor ist schnell. Das Betriebssystem wird Ihre Festplatten sowieso erneut anfordern (oder zumindest sollte es), um die geringsten Kopfbewegungen zu erhalten.