nvme

Methods

(static) createQueuePair() → {Number}

Example

// Creating a single IO queue pair
const qid1 = nvme.createQueuePair();
logger.info(`Created IO queue pair with Queue ID ${qid1}.`);

// Creating another IO queue pair
const qid2 = nvme.createQueuePair();
logger.info(`Created IO queue pair with Queue ID ${qid2}.`);

// If you want to create multiple queue pairs in a loop (assuming a hypothetical need to create 5 pairs)
for (let i = 0; i < 5; i++) {
    const qid = nvme.createQueuePair();
    logger.info(`Created IO queue pair with Queue ID ${qid}.`);
}

Returns:

Type

Number

(static) datasetManagement(ranges, options) → {nvme.CompletionQueueEntry}

Example

var response = nvme.datasetManagement(
     [{ length: 100, startLba: 2000 }, { length: 50, startLba: 2100 }],
     { nsid: 1, qid: 2, attributes: 0b010 }
 );
 logger.info("Command Status:", response.status);

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

(static) deleteQueuePair(qid)

Example

// Delete a specific IO queue pair with Queue ID 5
nvme.deleteQueuePair(5);
logger.info('Deleted IO queue pair with Queue ID 5.');

// Attempting to delete another IO queue pair with Queue ID 3
nvme.deleteQueuePair(3);
logger.info('Deleted IO queue pair with Queue ID 3.');

// If you want to delete multiple queue pairs sequentially (assuming a hypothetical range for demonstration)
for (let i = 1; i <= 10; i++) {
    nvme.deleteQueuePair(i);
    logger.info(`Deleted IO queue pair with Queue ID ${i}.`);
}

Parameters:

(static) disableCommandTracker()

(static) disableDataValidator(optionsopt)

Parameters:

(static) enableCommandTracker()

(static) enableDataValidator(optionsopt)

Parameters:

(static) formatNvm(nsid, lbaFormat, optionsopt) → {nvme.CompletionQueueEntry}

Example

// Format a specific namespace with default settings
nvme.formatNvm(1, 5);

// Format a specific namespace with User Data Erase secure settings and Protection Information enabled as Type 1
nvme.formatNvm(2, 7, { ses: 1, pi: 1 });

// Format with Cryptographic Erase and metadata in a separate buffer
nvme.formatNvm(3, 8, { ses: 2, mset: 0 });

// Format with Protection Information in the first bytes of metadata and metadata transferred as part of an extended LBA
nvme.formatNvm(4, 9, { pil: 1, mset: 1 });

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

(static) getDeviceInfo() → {nvme.DeviceInfo}

Returns:

Type

nvme.DeviceInfo

(static) getNamespaceInfo(nsid) → {nvme.NamespaceInfo}

Parameters:

Returns:

Type

nvme.NamespaceInfo

(static) loadDriver()

(static) probeController(options)

Parameters:

(static) read(startLba, numBlocks, options) → {nvme.CompletionQueueEntry}

Example

const startLba = 500;
const numBlocks = 5;

// Using default nsid and qid values
const result1 = nvme.read(startLba, numBlocks);
logger.info(result1);

// Specifying nsid and qid values
const options = { nsid: 2, qid: 3 };
const result2 = nvme.read(startLba, numBlocks, options);
logger.info(result2);

// Using only the required parameters
const startLba = 1000;
const numBlocks = 2;

const result3 = nvme.read(startLba, numBlocks);
logger.info(result3);

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

(static) registerPowerControl()

(static) resetController()

(static) sendAdminCommand(command, buffer, isHostToDevice) → {nvme.CompletionQueueEntry}

Example

// Example: Sending an "Identify" command using the NVMe "sendAdminCommand" API
var identifyBuffer = Buffer.alloc(4096);  // Allocating a 4K buffer to retrieve identify information

nvme.sendAdminCommand({
   nsid: 0,               // Namespace ID (0 for controller, specific ID for namespace)
   opc: 0x06,            // Opcode for Identify command
   cdw10: 1,             // Specify what to identify (1 = namespace, 2 = controller)
}, identifyBuffer, false);  // Set to false since we're expecting data from the device

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

(static) sendNvmCommand(qid, command, buffer, isHostToDevice) → {nvme.CompletionQueueEntry}

Example

// Example: Sending a "Write" command using the NVMe "sendNvmCommand" API
var writeDataBuffer = Buffer.from('This is data to be written to NVMe drive');
var startLBA = 0x1FFFFFFFF;  // starting Logical Block Address
var numLBAs = (writeDataBuffer.length / 512) - 1;  // number of LBAs to write, assuming 512-byte sectors and subtracting 1 as it's 0-based.

var lower32bits = startLBA % 0x100000000; // Equivalent to startLBA & 0xFFFFFFFF for values > 32-bits
var upper32bits = Math.floor(startLBA / 0x100000000); // Obtain the upper 32 bits by dividing

nvme.sendNvmCommand(1, {
   nsid: 1,
   opc: 0x01, // Opcode for Write command
   cdw10: lower32bits, // Starting LBA (lower 32 bits)
   cdw11: upper32bits, // Starting LBA (upper 32 bits)
   cdw12: numLBAs
}, writeDataBuffer, true);

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

(static) setCommandTrackerLog(filename)

Parameters:

(static) shutdown()

Example

// Initiating a controller shutdown
nvme.shutdown();

// You can log the shutdown initiation for record purposes
logger.info('Controller shutdown initiated.');

(static) startWorkloadGenerator(optionsopt) → {nvme.WorkloadResult}

Example

// basic workload generator type
nvme.startWorkloadGenerator({
   type: "basic",
   nsid: 1,
   queueDepth: 1024,
   xferSize: 4096,
   range: { startLba: 0x1234, size: 0x5 },
   loops: 1,
   duration: 60,
   nsid: 1,
   workload: 'random',
   readPercent: 50,
   alignment: 8, // Aligns Start LBA at 4K boundary if LBA size is 512B.
   xferSize: 4096,
   range: '100%'
})

// multiRange workload generator type
nvme.startWorkloadGenerator({
   type: "multiRange",
   nsid: 1,
   queueDepth: 1024,
   xferSize: 4096,
   range: { startLba: 0x1234, size: 0x5 },
   loops: 1,
   duration: 60,
   ranges: [
     {
       nsid: 1,
       workload: 'random',
       readPercent: 100,
       alignment: 0,
       startLba: 0,
       size: 10000,
       probability: 5,
       xfers: [
         { size: 512, probability: 5},
         { size: 1024, probability: 10},
         { size: 2048, probability: 20},
         { size: 4096, probability: 65}
       ]
     },
     {
       nsid: 1,
       workload: 'sequential',
       readPercent: 0,
       alignment: 8,
       startLba: 10000,
       size: 100000,
       probability: 95,
       xfers: [
         { size: 512, probability: 50},
         { size: 1024, probability: 50}
       ]
     }
   ]
})

Parameters:

Returns:

Type

nvme.WorkloadResult

(static) write(startLba, numBlocks, options) → {nvme.CompletionQueueEntry}

Example

const data = Buffer.from('0102030405060708', 'hex');
const startLba = 1000;
const numBlocks = 4;

// Using default nsid and qid values
const result1 = nvme.write(startLba, numBlocks, { dataPattern: data });
logger.info(result1);

// Specifying nsid and qid values
const options = { nsid: 2, qid: 3, dataPattern: data };
const result2 = nvme.write(startLba, numBlocks, options);
logger.info(result2);

// Using only the required parameters
const startLba = 2000;
const numBlocks = 3;

const result3 = nvme.write(startLba, numBlocks);
logger.info(result3);

Parameters:

Returns:

Type

nvme.CompletionQueueEntry

Type Definitions

CommandErrorHistory

Properties:

Type:

• Object

CompletionQueueEntry

Properties:

Type:

• object

CompletionStatus

Properties:

Type:

• object

DeviceInfo

Properties:

Type:

• Object

NamespaceInfo

Properties:

Type:

• Object

WorkloadGeneratorBasicOptions

Properties:

Type:

• Object

WorkloadGeneratorFeatures

Properties:

Type:

• Object

WorkloadGeneratorMultiRangeOptions

Properties:

Type:

• Object

WorkloadResult

Properties:

Type:

• Object

WorkloadResultBasicInfo

Properties:

Type:

• Object

WorkloadResultLatency

Properties:

const result = nvme.startWorkloadGenerator({
  features: {
    intervalStats: {
      enabled: true
    }
  }
})
const data = result.read.intervalData
data.forEach((item) => {
  logger.info(`${item.throughput}B/s at ${item.sinceStart}s`)
})

Type:

• Object

WorkloadResultMultiRangeInfo

Properties:

Type:

• Object