मैक ओएस एक्स में एसएसडी का पता लगाने के लिए कैसे?

Question

क्या कोई विश्वसनीय, त्वरित, निर्धारिक तरीका है (यानी बेंचमार्क) यह जांचने के लिए कि सिस्टम ड्राइव मैक ओएस एक्स चालू है या नहीं, एक ठोस राज्य ड्राइव है?

क्या कोई अन्य संकेतक है कि डिस्क समानांतर पहुंच को कितनी अच्छी तरह से संभालती है? मैं डिस्क के बाध्य संचालन के लिए उपयोग करने वाले धागे की संख्या को समायोजित करने की कोशिश कर रहा हूं।

मुझे कच्ची गति में दिलचस्पी नहीं है या समय तलाशना है, केवल किस प्रकार की पहुंच - धारावाहिक या समांतर - ड्राइव के लिए तेज़ है। मैं अपने प्रोग्राम के उपयोगकर्ताओं को iSCSI या RAID का उपयोग करने की उम्मीद नहीं करता हूं। एसएसडी मेरा ध्यान है, और कुछ भी अच्छा है।

Device CharacteristicsIOAHCIBlockStorageDevice में यह जानकारी शामिल है। मैं इसे प्रोग्रामेटिक रूप से कैसे पढ़ सकता हूं? (निम्नलिखित स्यूडोकोड है)

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); 
} 

---

संपादित करें::

---

अब तक मैं समझ गए होंगे कि यह इस प्रकार है Here's complete source code। मैंने सत्यापित किया है कि यह इंटेल एसएसडी और ओसीजेड वर्टेक्स के साथ काम करता है।

Answer 1

यदि आप उस तरह की जानकारी प्राप्त करने का प्रयास कर रहे हैं, तो आपको सबसे अच्छा अनुमान है IOKit।

आप इसके बारे में कुछ कोशिश कर सकते हैं ioreg कमांड लाइन टूल या IORegistryExplorer का उपयोग कर सुविधा है।

---

यहां कुछ कोड है जो आपकी मदद कर सकता है। यह उन सभी हार्ड ड्राइव को लाता है जो RAID नहीं हैं और विभाजन नहीं हैं। यह वही नहीं है जो आप चाहते हैं, लेकिन यह आपको शुरू हो सकता है।

#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

असल में, मुझे लगता है कि आपको बेंचमार्किंग मार्ग जाना चाहिए, क्योंकि यह आपके प्रश्न का अधिक सटीक उत्तर देता है - आप वास्तव में परवाह नहीं करते हैं कि डिस्क एक एसएसडी होने के कारण होती है, आप बस देखभाल करते हैं कि डिस्क वास्तव में तेज़ है। क्या होगा यदि उपयोगकर्ता एक तेज RAID सेटअप, या एक फाइबर चैनल सरणी का उपयोग कर रहा है, या iSCSI का उपयोग कर रहा है?

बस अंतर्निहित/dev/diskX से यादृच्छिक क्षेत्रों में से एक गुच्छा पढ़ सकते हैं और ड्राइव

Answer 3

थ्रेड की संख्या अगर यह आपके आवश्यकताओं को पूरा आप एक "फास्ट" के रूप में यह इलाज कर सकते हैं? 1 किसी भी डिस्क, एसएसडी, RAID या नहीं overwhelm जा रहा है। डिस्क धीमी है, प्रोसेसर तेज है। ओएस कम से कम सिर आंदोलनों को पाने के लिए किसी भी तरह से (या कम से कम इसे चाहिए) अपने डिस्क अनुरोधों को फिर से व्यवस्थित करने जा रहा है।