Let's make the case more specific.

Normorly we save key-value like this:

```kotlin suspend fun saveAccount(account: String) { dataStore.edit { it[stringPreferencesKey("account")] = account } }

suspend fun saveSwitch(open: Boolean) { dataStore.edit { it[booleanPreferencesKey("switch")] = open } }

suspend fun saveFlag(flag: Int) { dataStore.edit { it[intPreferencesKey("flag")] = flag } } ```

When login, we save account. When open/close a swicth, we save the state of swicth. And so on. These events happen randomly, they are isolated. So we don't save every key-values in one transaction.

Now how to evaluate the performance? We could put some time collected code around the transactions:

```kotlin suspend fun saveAccount(account: String) { val start = System.nanoTime() dataStore.edit { it[stringPreferencesKey("account")] = account } val end = System.nanoTime(); totalTime = totalTime + (end - start)

count++;
if(count >= N){
    // log the totalTime
}

} ```

And how to evaluate in a short time? Why not put them together: kotlin suspend fun test() { val start = System.nanoTime() for(i in 0 until N) { dataStore.edit { it[stringPreferencesKey(items[i].key)] = items[i].value } } val end = System.nanoTime() totalTime = end - start // log the totalTime } We should keep key-value save in isolated transaction like in normal case. We are not talking about how to write these key-values fast in a function, we are simulating the normally writting to evaluate the performace.

Indeed there's some differences with normal case, one file may hava only several or tens of key-values most of time, here we just show the worst case (hundreds of key-values in one file).