How do I calculate MB/s & MiB/s?

Question

I've recently discovered that MB/s is technically equivalent to 8 million bits/s and not 1024² bits per second which should be called a Mebibyte.

This should be easy, but when comparing output from various sources I get different answers, even from google which thinks there is no difference at all between the measures.

If I transfer 1381530 bytes in 17797601 nanoseconds, what is the data rate in those two measures? and what is the formula you're using to calculate it?

Currently I have: where duration is in nanoseconds.

double data_rate_MiBps = (num_bytes/1024/1000) / ((double)duration * 1e-9);
double data_rate_MBps = (num_bytes/1024/1024) / ((double)duration * 1e-9);

Thanks for the responses. I was ending up with numbers that didn't make sense before but now they do. The above code should be the following:

double data_rate_MiBps = (num_bytes/1024.0/1000.0) / ((double)duration * 1e-9);
double data_rate_MBps = (num_bytes/1024.0/1024.0) / ((double)duration * 1e-9);

I therefore get:

74.085 MiB/s
75.863 MB/s

Which I think makes sense.

Probably a better question. Why in the first place was 1024 bytes chosen to be 1KB instead of 1000. Since Kilo (etc) = 1000 everywhere else.

Answer 1

See

1> Megabyte per second

A megabyte per second (MB/s or MBps) is a unit of data transfer rate equal to:

1,000,000 bytes per second,

2> Megabit per second

A megabit per second (Mbit/s, Mb/s, or Mbps) is a unit of data transfer rate equal to:

1,000,000 bits per second

3>Mebibyte per second

A mebibyte per second (MiB/s or MiBps) is a unit of data transfer rate equal to:

1,048,576 bytes per second, or

4>Mebibit per second

A mebibit per second (Mibit/s or Mib/s) is a unit of data transfer rate equal to:

1,048,576 bits per second or

Answer 2

10³ = Kilo

10⁶ = Mega/Million

10⁹ = Giga/Billion

That's what you should have already taught in school. But when you're calculating Bytes, the calculations are slightly different:

2¹⁰ bytes = 1024 bytes = 1 Kilobyte

2²⁰ bytes = 1024² bytes = 1 Megabyte

2³⁰ bytes = 1024³ bytes = 1 Gigabyte

Of course, no one will blame you if you use 10⁶ bytes as 1 Megabyte. HDD manufactures use 10⁹ bytes as 1 Gigabyte.

To make calculations unambiguous, MiB/s (or GiB/s) is often used instead of MB/s (or GB/s) when referring to bytes. Thus, 1 MiB/s actually means 1024² bytes per second. Yet, you'll see many areas where simply MB is used to indicate 1024² bytes (e.g., Windows).

Now, it's upto you how you calculate MB/s. If you use MiB/s, then you should stick to the convention and use 1024² instead of 10⁶.

Answer 3

Probably a better question. Why in the first place was 1024 bytes chosen to be 1KB instead of 1000? Since Kilo (etc) = 1000 everywhere else.

The prefixes Kilo, Mega, Giga, and Tera come from the metric system, which was designed to use powers of 10, since we all use base 10. But computers use base 2, so quantities are better defined as powers of 2 rather than 10. By coincidence, 2¹⁰ is roughly equal to 10³. So computer professionals started referring to 2¹⁰ as Kilo, and 2²⁰ as Mega, and so on. Integer values are expressed as values using 8, 16, 32, or 64 bits, which are also powers of 2. Memory addresses are bound at powers of 2. So 16 bits of address space can access 2¹⁶ bytes of memory. Also, since a 32-bit processor can access 2³² addresses, or 2² Giga-addresses of 8 bits each, it can use 4 gigabytes of memory. This is why memory chips come in sizes like 1GB which means 2³⁰ bytes.

So, when referring to values that are better measured as powers of 2, it makes more sense to define kilo, mega, and giga as 2¹⁰, 2²⁰, and 2³⁰.

Answer 4

It is correct that mega is an SI prefix unit so it is technically should refer to 1 000 000 bytes, while the mebi prefix should refer to 2²⁰.

Online converters do not always follow modern standard since until recently a lot of people, hardware companies, and OSes confuses the definition of mega and uses it for the binary prefix sometimes inconsistently.

Answer 5

They use 1024 instead of 1000 because its divisible by 2. Computers are binary and they calculate bytes by multiplying by 2. Where they start by multiply 2 by 2 and getting 4 and doubling that to 8 and so on till you get to 1024 next would be 2048 and then 4096.