partedでパフォーマンスの警告が出た場合の対処法

Warning: The resulting partition is not properly aligned for best performance.

(parted) mkpart primary 2048s -1s

(parted) mkpart primary 64s -1s

if ((alignment == ALIGNMENT_OPTIMAL &&
		 !partition_align_check(disk, part, PA_OPTIMUM)) ||
		(alignment == ALIGNMENT_MINIMAL &&
		 !partition_align_check(disk, part, PA_MINIMUM))) {
				if (ped_exception_throw(
								PED_EXCEPTION_WARNING,
								(opt_script_mode
								 ? PED_EXCEPTION_OK
								 : PED_EXCEPTION_IGNORE_CANCEL),
								_("The resulting partition is not properly "
									"aligned for best performance.")) ==
						PED_EXCEPTION_CANCEL) {
								/* undo partition addition */
								goto error_remove_part;
				}
}

/* Return true if partition PART is consistent with DISK's selected
   offset and alignment requirements.  Also return true if there is
   insufficient kernel support to determine DISK's alignment requirements.
   Otherwise, return false.  A_TYPE selects whether to check for minimal
   or optimal alignment requirements.  */
static bool
partition_align_check (PedDisk const *disk, PedPartition const *part,
		       enum AlignmentType a_type)
{
  PED_ASSERT (part->disk == disk, return false);
  PedDevice const *dev = disk->dev;

  PedAlignment *pa = (a_type == PA_MINIMUM
		      ? ped_device_get_minimum_alignment (dev)
		      : ped_device_get_optimum_alignment (dev));
  if (pa == NULL)
    return true;

  PED_ASSERT (pa->grain_size != 0, return false);
  bool ok = (part->geom.start % pa->grain_size == pa->offset);
  free (pa);
  return ok;
}

/**
 * Get an alignment that represents minimum hardware requirements on alignment.
 * When for example using media that has a physical sector size that is a
 * multiple of the logical sector size, it is desirable to have disk accesses
 * (and thus partitions) properly aligned. Having partitions not aligned to
 * the minimum hardware requirements may lead to a performance penalty.
 *
 * The returned alignment describes the alignment for the start sector of the
 * partition, the end sector should be aligned too, to get the end sector
 * alignment decrease the returned alignment's offset by 1.
 *
 * \return the minimum alignment of partition start sectors, or NULL if this
 *         information is not available.
 */
PedAlignment*
ped_device_get_minimum_alignment(const PedDevice *dev)
{
        PedAlignment *align = NULL;

        if (ped_architecture->dev_ops->get_minimum_alignment)
                align = ped_architecture->dev_ops->get_minimum_alignment(dev);

        if (align == NULL)
                align = ped_alignment_new(0,
                                dev->phys_sector_size / dev->sector_size);

        return align;
}

/**
 * Get an alignment that represents the hardware requirements for optimal
 * performance.
 *
 * The returned alignment describes the alignment for the start sector of the
 * partition, the end sector should be aligned too, to get the end sector
 * alignment decrease the returned alignment's offset by 1.
 *
 * \return the optimal alignment of partition start sectors, or NULL if this
 *         information is not available.
 */
PedAlignment*
ped_device_get_optimum_alignment(const PedDevice *dev)
{
        PedAlignment *align = NULL;

        if (ped_architecture->dev_ops->get_optimum_alignment)
                align = ped_architecture->dev_ops->get_optimum_alignment(dev);

        /* If the arch specific code could not give as an alignment
           return a default value based on the type of device. */
        if (align == NULL) {
                switch (dev->type) {
                case PED_DEVICE_DASD:
                        align = ped_device_get_minimum_alignment(dev);
                        break;
                default:
                        /* Align to a grain of 1MiB (like vista / win7) */
                        align = ped_alignment_new(0,
                                                  1048576 / dev->sector_size);
                }
        }

        return align;
}