tequilaOS/platform_system_vold
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_system_vold/BenchmarkGen.h

4474 lines
216 KiB
C
Raw Normal View History

Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/******************************************************************
* THIS CODE WAS GENERATED BY benchgen.py, DO NOT MODIFY DIRECTLY *
******************************************************************/
Track rename from base/ to android-base/. Change-Id: I3096cfa50afa395d8e9a8043ab69c1e390f86ccb
2015-12-05 00:50:53 +01:00
#include <android-base/logging.h>
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sendfile.h>
#include <fcntl.h>
#include <algorithm>
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
#include <functional>
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
#include <string>
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
#include <Utils.h>
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
namespace android {
namespace vold {
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
static status_t BenchmarkRun(std::function<bool(int)> checkpoint) {
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
char* buf = (char*) malloc(1048576);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3433f17 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(lseek(t3433f17, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f17, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f17, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 278721));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 19, 278751));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 25119, 278528)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 37276895));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 14, 37276925));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 914520, 37273600)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3433f18 = TEMP_FAILURE_RETRY(open("file1", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 466944, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 466944)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 471040, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 5965501));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 11, 5965531));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file2", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 1048576, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 57012224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 1048576, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 6473855));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 6473885));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 8916226));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 8916256));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 11368292));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 11368322));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 13996125));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 13996155));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 16595549));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 16595579));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 19217798));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 19217828));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 22047170));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 22047200));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3433f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3433f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3433f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 30, 24961213));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 12, 24961243));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file3", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file4", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file5", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 38736, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4304, 36864)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file6", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 2348, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4636, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file7", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 778948, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 16736, 778240)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file8", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 18099, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4264, 16384)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file9", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 22960, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4108, 20480)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3433f18 = TEMP_FAILURE_RETRY(open("file10", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 13748, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f18, buf, 4196, 12288)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3433f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 278721));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 19, 278751));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 25119, 278528)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 35727447));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 33, 35727477));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 2805, 35725312)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 29869066));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 33, 29869096));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 1891, 29868032)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 34413225));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 49, 34413255));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 3143, 34410496)); // mmap2
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 30, 32521955));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 45, 32521985));
TEMP_FAILURE_RETRY(pread(t3433f17, buf, 6350, 32518144)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3450f18 = TEMP_FAILURE_RETRY(open("file11", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
int t3450f22 = TEMP_FAILURE_RETRY(open("file12", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3450f22, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3450f22);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3450f22 = TEMP_FAILURE_RETRY(open("file13", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3450f22);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3450f22 = TEMP_FAILURE_RETRY(open("file14", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3450f22);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3450f22 = TEMP_FAILURE_RETRY(open("file15", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3450f22, buf, 1));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fsync(t3450f22));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3450f22);
close(t3450f18);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3454f26 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(lseek(t3454f26, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3454f26, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3454f26, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3454f26, buf, 769726, 38187008)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3454f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3454f26 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(lseek(t3454f26, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3454f26, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3454f26, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3454f26, buf, 769726, 38187008)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3454f26);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3455f17 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(lseek(t3455f17, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f17, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f17, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 278721));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 19, 278751));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 25119, 278528)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 37276895));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 14, 37276925));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 914520, 37273600)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3454f29 = TEMP_FAILURE_RETRY(open("file16", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3454f29, buf, 14048, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3454f29);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3455f18 = TEMP_FAILURE_RETRY(open("file1", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 466944, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 466944)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 471040, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 5965501));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 11, 5965531));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file2", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 1048576, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 57012224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 1048576, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(52)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 6473855));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 6473885));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 8916226));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 8916256));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 11368292));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 11368322));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 13996125));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 13996155));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 16595549));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 16595579));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 19217798));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 19217828));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 22047170));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 22047200));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 4));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_SET));
TEMP_FAILURE_RETRY(lseek(t3455f18, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3455f18, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3455f18, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 769726, 38187008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 30, 24961213));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 12, 24961243));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file3", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file4", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file5", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 38736, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4304, 36864)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file6", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 2348, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4636, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file7", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 778948, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 16736, 778240)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file8", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 18099, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4264, 16384)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file9", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 22960, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4108, 20480)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3455f18 = TEMP_FAILURE_RETRY(open("file11", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 3513185));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 3513215));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3262, 3510272)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 3513185));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 3513215));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3262, 3510272)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3455f19 = TEMP_FAILURE_RETRY(open("file12", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3455f19, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f19);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f19 = TEMP_FAILURE_RETRY(open("file13", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f19);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f19 = TEMP_FAILURE_RETRY(open("file14", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f19);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3455f19 = TEMP_FAILURE_RETRY(open("file15", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3455f19, buf, 1));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fsync(t3455f19));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f19);
close(t3455f18);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f18 = TEMP_FAILURE_RETRY(open("file10", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 13748, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f18, buf, 4196, 12288)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f18);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f20 = TEMP_FAILURE_RETRY(open("file17", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f21 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f21, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f21);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 0));
t3483f21 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f21, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f21);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 16, 24));
t3483f21 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f21, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f21);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 8192));
t3483f21 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f21, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f21);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 16, 24));
t3483f21 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f21, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f21);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 12288));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f22 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f22, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f22);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 28672));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 32768));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 36864));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 81920));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 98304));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 163840));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 57344));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 147456));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 151552));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 155648));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 143360));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 65536));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 122880));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 73728));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 126976));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 90112));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 135168));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 106496));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 110592));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 49152));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 139264));
TEMP_FAILURE_RETRY(pread(t3483f20, buf, 4096, 172032));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f25 = TEMP_FAILURE_RETRY(open("file19", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f26 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 0));
t3483f26 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
t3483f26 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 8192));
t3483f26 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
t3483f26 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 12288));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3483f27 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f27, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f27);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 24576));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 40960));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 110592));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 172032));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 151552));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 77824));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 155648));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 180224));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 106496));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 167936));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 94208));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 163840));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 49152));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 159744));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 176128));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 36864));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 98304));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 61440));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 86016));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 147456));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 143360));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 45056));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 73728));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 32768));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 122880));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 126976));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 28672));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 53248));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 118784));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 57344));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 135168));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 65536));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 184320));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 69632));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 81920));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 90112));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(55)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 102400));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 114688));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 131072));
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 4096, 139264));
t3483f27 = TEMP_FAILURE_RETRY(open("file20", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3483f27, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3483f27);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3483f25, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3498f30 = TEMP_FAILURE_RETRY(open("file21", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3498f30, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3498f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 278721));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 19, 278751));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 25119, 278528)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f31 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f31, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
t3499f30 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
t3499f31 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3500f30 = TEMP_FAILURE_RETRY(open("file23", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 27898, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4124, 24576)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3500f30 = TEMP_FAILURE_RETRY(open("file24", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 91256, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4108, 90112)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3500f30 = TEMP_FAILURE_RETRY(open("file25", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 30332, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4200, 28672)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3500f30 = TEMP_FAILURE_RETRY(open("file26", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 26408, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4100, 24576)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3500f30 = TEMP_FAILURE_RETRY(open("file27", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 50044, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4128, 49152)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3500f30 = TEMP_FAILURE_RETRY(open("file28", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 1048576, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3500f30, buf, 122564, 3059712)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3500f30);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3502f30 = TEMP_FAILURE_RETRY(open("file29", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 4));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 44));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 29));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 36));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 21));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 17));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 47));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 23));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 28));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 24));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 45));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 21));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 37));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 22));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 17));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 36));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 37));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 22));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 22));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 46));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 29));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 31));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 32));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 31));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 37));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 1));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 2));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 21));
TEMP_FAILURE_RETRY(read(t3502f30, buf, 8));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3502f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35167565));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 35167595));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4148, 35164160)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34342181));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34342211));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1656, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32761881));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 32761911));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3104, 32759808)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34343387));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 32, 34343417));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2828, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34343692));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 34343722));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3201, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34344392));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 34344422));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3897, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34344065));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 34344095));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3528, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34344761));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 34344791));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4269, 34340864)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34345456));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 34345486));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 865, 34344960)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34345133));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 34345163));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 496, 34344960)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36096678));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 36096708));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3292, 36093952)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34698049));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 34698079));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1211, 34697216)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32760711));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 31, 32760741));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2073, 32759808)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32273035));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 32273065));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(58)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1692, 32272384)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34612102));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 34612132));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1313, 34611200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34765885));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 34765915));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3387, 34762752)); // mmap2
t3499f31 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f31, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f31 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f31, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f32 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f32));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f31 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f31, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f31 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f31, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
t3499f32 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f32));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
TEMP_FAILURE_RETRY(pwrite(t3499f31, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f31));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f31);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f31 = TEMP_FAILURE_RETRY(open("file30", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f32 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f32, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 0));
t3492f32 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f32, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
t3492f32 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f32, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 8192));
t3492f32 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f32, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
t3492f32 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f32, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f32);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35635385));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 35635415));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1005, 35635200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 12288));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f33 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f33);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 24576));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 77824));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 73728));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 69632));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 81920));
t3492f33 = TEMP_FAILURE_RETRY(open("file32", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 23336, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36386416));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 32, 36386446));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2082, 36384768)); // mmap2
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f34 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f34));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f34);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
t3499f34 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f34));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f34);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36389306));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 23, 36389336));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1664, 36388864)); // mmap2
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f30 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f30, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
t3499f34 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f34));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f34);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
TEMP_FAILURE_RETRY(pwrite(t3499f30, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f30));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34762881));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 54, 34762911));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f30);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 463, 34762752)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28270957));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 28270987));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 667, 28270592)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34750025));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 34750055));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4004, 34746368)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 1468611));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 1468641));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58877, 1466368)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31697557));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 31697587));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3884, 31694848)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34293434));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 34293464));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2090, 34291712)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32918186));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 32918216));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3139, 32915456)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32915891));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 32915921));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2060, 32915456)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32917516));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 32917546));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2476, 32915456)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32918595));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 32918625));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4994, 32915456)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32917932));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 35, 32917962));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2730, 32915456)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35461407));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 31, 35461437));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2723, 35459072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35474138));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 35474168));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3682, 35471360)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34394223));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(61)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 34394253));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 481, 34394112)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32648704));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 32648734));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4644, 32645120)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32654567));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58, 32654597));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1606, 32653312)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32649764));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 52, 32649794));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1553, 32649216)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32654918));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 62, 32654948));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1979, 32653312)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31696162));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 56, 31696192));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2367, 31694848)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 9032, 20480)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 24216, 28672)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 25168, 49152)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 10560, 73728)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 13256, 81920)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 6664, 94208)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 22688, 98304)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 57408, 118784)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f33, buf, 3064, 176128)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f33);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36097244));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 36097274));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3608, 36093952)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36096678));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 36096708));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3292, 36093952)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3509f41 = TEMP_FAILURE_RETRY(open("file33", O_RDONLY|O_LARGEFILE));
int t3492f42 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f42, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 53248));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f42 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f42, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3509f41, buf, 8192));
TEMP_FAILURE_RETRY(read(t3509f41, buf, 8091));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3509f41);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f41 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f41, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f41 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f41, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
t3499f42 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f42));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f41 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f41, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f41 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f41, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
t3499f42 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f42));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
TEMP_FAILURE_RETRY(pwrite(t3499f41, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f41 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f41, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f40 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 36864));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
t3499f42 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f42));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
t3499f42 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f42));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
t3499f42 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f42));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f41 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f41, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f41);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 45056));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 90112));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 94208));
t3492f41 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f41, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f41);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 61440));
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35636928));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 60, 35636958));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2062, 35635200)); // mmap2
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 12828));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(64)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
t3499f41 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f41));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f41);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f40 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f40, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3508f42 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(lseek(t3508f42, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3508f42, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3508f42, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3508f42, buf, 769726, 38187008)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3508f42);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3508f42 = TEMP_FAILURE_RETRY(open("file0", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(lseek(t3508f42, 0, SEEK_END));
TEMP_FAILURE_RETRY(lseek(t3508f42, 38891199, SEEK_SET));
TEMP_FAILURE_RETRY(read(t3508f42, buf, 65557));
TEMP_FAILURE_RETRY(pread(t3508f42, buf, 769726, 38187008)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3508f42);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f43 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f43));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f43);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
TEMP_FAILURE_RETRY(pwrite(t3499f40, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f40));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f40);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3508f40 = TEMP_FAILURE_RETRY(open("file16", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3508f40, buf, 14048, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3508f40);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f33 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f33, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f33);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f33 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f33, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f39 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f39));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f39);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f33);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f33 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f33, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f33);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f33 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f33, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
t3499f39 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f39));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f39);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
TEMP_FAILURE_RETRY(pwrite(t3499f33, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f33));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f33);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35635115));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 35635145));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4281, 35631104)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35448800));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 31, 35448830));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2408, 35446784)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f33 = TEMP_FAILURE_RETRY(open("file34", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f33, buf, 1422));
TEMP_FAILURE_RETRY(read(t3519f33, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f33);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35378185));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35378215));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1535, 35377152)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35378687));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35378717));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2578, 35377152)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35194783));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 27, 35194813));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2574, 35192832)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34408303));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 34408333));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2280, 34406400)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32465635));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 32465665));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4145, 32464896)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35284839));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 35284869));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2433, 35282944)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34435656));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 34435686));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 905, 34435072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32557274));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 64, 32557304));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 8345, 32555008)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32547670));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 63, 32547700));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 10458, 32546816)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32547259));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 32547289));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 854, 32546816)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35562037));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 35562067));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1486, 35561472)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34535858));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34535888));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2793, 34533376)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34103026));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 34103056));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4170, 34099200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35453961));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 35453991));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3619, 35450880)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29898896));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 29898926));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2817, 29896704)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28212186));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 28212216));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3308, 28209152)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28212460));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 28212490));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3585, 28209152)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34435977));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 34436007));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1227, 34435072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29899521));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 53, 29899551));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3195, 29896704)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29898513));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 29898543));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2192, 29896704)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35344567));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35344597));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 529, 35344384)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35344913));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35344943));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1043, 35344384)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32576839));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 32576869));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 5361, 32575488)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35254403));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 35254433));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 650, 35254272)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35722278));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 35722308));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1541, 35721216)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35894101));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 51, 35894131));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1698, 35893248)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34723655));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 34723685));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2180, 34721792)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35610903));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35610933));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 726, 35610624)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35722757));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 35722787));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1939, 35721216)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35283991));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 35284021));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1461, 35282944)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35276797));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35276827));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2365, 35274752)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29897692));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 29897722));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1809, 29896704)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3523f49 = TEMP_FAILURE_RETRY(open("file33", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3523f49, buf, 8192));
TEMP_FAILURE_RETRY(read(t3523f49, buf, 8091));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3523f49);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3455f50 = TEMP_FAILURE_RETRY(open("file7", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f50 = TEMP_FAILURE_RETRY(open("file35", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 117507, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4100, 114688)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f50 = TEMP_FAILURE_RETRY(open("file36", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 187587, 0)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(67)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4128, 188416)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f50 = TEMP_FAILURE_RETRY(open("file24", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f50 = TEMP_FAILURE_RETRY(open("file37", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 155576, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4104, 155648)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3455f50 = TEMP_FAILURE_RETRY(open("file38", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 61218, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f50, buf, 4280, 61440)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3455f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29922405));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 29922435));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1962, 29921280)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f50 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f50, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f50);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f50 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f50, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f52 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f52));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f52);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f50 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f50, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f50);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f50 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f50, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
t3499f52 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f52));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f52);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
TEMP_FAILURE_RETRY(pwrite(t3499f50, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f50));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34609966));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 26, 34609996));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3291, 34607104)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31439600));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 31439630));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3729, 31436800)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 33255456));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 33255486));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 795, 33255424)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f52 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f52, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f52);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 4096, 28672));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35345427));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 31, 35345457));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1460, 35344384)); // mmap2
t3492f52 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3492f52, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f52);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35946630));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 27, 35946660));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 376, 35946496)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35282311));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 35, 35282341));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4412, 35278848)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28266007));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 28266037));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3898, 28262400)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28271259));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 28271289));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 960, 28270592)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29218555));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 29218585));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2281, 29216768)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28771544));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 28771574));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2470, 28770304)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31103055));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 31103085));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3471, 31100928)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34430076));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34430106));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3543, 34426880)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32574817));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 32574847));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4265, 32571392)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511105));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35511135));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3217, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511441));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35511471));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3780, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29943458));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 29943488));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2309, 29941760)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513993));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35514023));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2120, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34446657));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 53, 34446687));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3721, 34443264)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513539));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35513569));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1673, 35512320)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f50 = TEMP_FAILURE_RETRY(open("file39", O_RDONLY|O_LARGEFILE));
int t3526f52 = TEMP_FAILURE_RETRY(open("file40", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3526f52, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3526f52, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3526f52, buf, 1584, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3526f52, buf, 4172, 0)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f52);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34434708));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34434738));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4060, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32576277));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 32576307));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1351, 32575488)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31155301));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 31155331));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1721, 31154176)); // mmap2
TEMP_FAILURE_RETRY(read(t3526f50, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f50, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34433783));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 34433813));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3113, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32575657));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 32575687));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 451, 32575488)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f50 = TEMP_FAILURE_RETRY(open("file41", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36042811));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 36042841));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2688, 36040704)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31522913));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 31522943));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2245, 31522816)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29920348));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 29920378));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 5221, 29917184)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3527f50 = TEMP_FAILURE_RETRY(open("file42", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3527f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3527f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32567874));
TEMP_FAILURE_RETRY(pread(t3527f50, buf, 26358, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 53, 32567904));
TEMP_FAILURE_RETRY(pread(t3527f50, buf, 4160, 24576)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 6297, 32567296)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3527f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32566237));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 32566267));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4674, 32563200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32564659));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 32564689));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3037, 32563200)); // mmap2
t3519f50 = TEMP_FAILURE_RETRY(open("file43", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f50);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f50 = TEMP_FAILURE_RETRY(open("file44", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f50, buf, 52, 0));
TEMP_FAILURE_RETRY(pread(t3492f50, buf, 4096, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f50, buf, 10313, 0)); // mmap2
TEMP_FAILURE_RETRY(pread(t3492f50, buf, 4136, 8192)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f50 = TEMP_FAILURE_RETRY(open("file45", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f50, buf, 16384));
t3526f52 = TEMP_FAILURE_RETRY(open("file46", O_RDONLY|O_LARGEFILE));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f50);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3526f52, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f52, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f52);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f53 = TEMP_FAILURE_RETRY(open("file47", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f53, buf, 16384));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f47 = TEMP_FAILURE_RETRY(open("file48", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f53, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f53);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3533f47, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f47, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f47);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f43 = TEMP_FAILURE_RETRY(open("file49", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f43, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f43);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f43 = TEMP_FAILURE_RETRY(open("file50", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f43, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f43);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f43 = TEMP_FAILURE_RETRY(open("file51", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3533f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f43, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f43);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f43 = TEMP_FAILURE_RETRY(open("file52", O_RDONLY|O_LARGEFILE));
t3532f53 = TEMP_FAILURE_RETRY(open("file53", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3519f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f43, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f53, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f53, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f43);
close(t3532f53);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f57 = TEMP_FAILURE_RETRY(open("file54", O_RDONLY|O_LARGEFILE));
if (!checkpoint(70)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3492f57, buf, 39938));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f57);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f61 = TEMP_FAILURE_RETRY(open("file55", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3492f61, buf, 8192));
TEMP_FAILURE_RETRY(read(t3492f61, buf, 8192));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3492f61 = TEMP_FAILURE_RETRY(open("file56", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3492f61, buf, 8192));
TEMP_FAILURE_RETRY(read(t3492f61, buf, 8192));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34957756));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 34957786));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3273, 34955264)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34267550));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34267580));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 722, 34267136)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34439777));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 34439807));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 920, 34439168)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35154576));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 35154606));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3467, 35151872)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34418681));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 34418711));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 339, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31439600));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 31439630));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3729, 31436800)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34420375));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 34420405));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2143, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31439101));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 31439131));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2800, 31436800)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34420831));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34420861));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2549, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31442196));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 31442226));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2300, 31440896)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34421573));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 34421603));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3344, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34429110));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 51, 34429140));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2566, 34426880)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32573593));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 32573623));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2814, 32571392)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36353719));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 36353749));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2179, 36352000)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34434392));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34434422));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3732, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34442017));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 34442047));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3276, 34439168)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34957756));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 34957786));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3273, 34955264)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35154576));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 35154606));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3467, 35151872)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34433472));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34433502));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2807, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34438470));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 63, 34438500));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3681, 34435072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35281553));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35281583));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3463, 35278848)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34419413));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 51, 34419443));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1188, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511105));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35511135));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3217, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511441));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35511471));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3780, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513993));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35514023));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2120, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513539));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35513569));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1673, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28977951));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 28977981));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3292, 28975104)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f56 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f56));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f55 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f55, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f55);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f55 = TEMP_FAILURE_RETRY(open("file57", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f55, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f55, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f55);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f55 = TEMP_FAILURE_RETRY(open("file58", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f56 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f56, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f55, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f55, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f55);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f56 = TEMP_FAILURE_RETRY(open("file59", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f59 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f59));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f59);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f55 = TEMP_FAILURE_RETRY(open("file60", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3533f55, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f55, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f55);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f58 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f58, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f58);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f58 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f58, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f58));
t3499f59 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f59));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f59);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f58));
TEMP_FAILURE_RETRY(pwrite(t3499f58, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f58));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f58);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36353719));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 36353749));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2179, 36352000)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34428771));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 59, 34428801));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2230, 34426880)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34441089));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 34441119));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2381, 34439168)); // mmap2
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
t3499f58 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f58));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f58);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f55 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4612));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(73)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f55, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
t3499f58 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f58));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f58);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
TEMP_FAILURE_RETRY(pwrite(t3499f55, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f55));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f55);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 20552));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35601253));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 35601283));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3224, 35598336)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35601560));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 35601590));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3832, 35598336)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511441));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35511471));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3780, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29923242));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 29923272));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3511, 29921280)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28272466));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 28272496));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2171, 28270592)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513993));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35514023));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2120, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34446657));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 53, 34446687));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3721, 34443264)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513539));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35513569));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1673, 35512320)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 16008));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31153857));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 31153887));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4461, 31150080)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 10864));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34907552));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 34907582));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2551, 34906112)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31809921));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 71, 31809951));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 7755, 31809536)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34423668));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 60, 34423698));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1203, 34422784)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 30431338));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 30431368));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4400, 30429184)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 14320));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34416128));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 34416158));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1855, 34414592)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29893363));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 66, 29893393));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1244, 29892608)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29892892));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58, 29892922));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 755, 29892608)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 12208));
TEMP_FAILURE_RETRY(write(t3505f56, buf, 20736));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36353719));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 43, 36353749));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2179, 36352000)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f56, buf, 8936));
TEMP_FAILURE_RETRY(write(t3505f56, buf, 2800));
TEMP_FAILURE_RETRY(write(t3505f56, buf, 20216));
TEMP_FAILURE_RETRY(write(t3505f56, buf, 16912));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f56 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f56, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f56);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3505f56 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 16924));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f62 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f62, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f62);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 16928));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 16932));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 21028));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 21032));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4096, 21036));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 4, 25132));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f62 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f62, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f68 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f68));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
TEMP_FAILURE_RETRY(pread(t3505f56, buf, 8, 25600));
TEMP_FAILURE_RETRY(fdatasync(t3505f56));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f62);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f62 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3505f62));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f62);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f56));
TEMP_FAILURE_RETRY(pwrite(t3505f56, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f56));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f56 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f56, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f56);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f56 = TEMP_FAILURE_RETRY(open("file61", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3533f56, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f56, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f56);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f56 = TEMP_FAILURE_RETRY(open("file62", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f56, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f56, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3532f56 = TEMP_FAILURE_RETRY(open("file63", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3532f56, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f56, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f56, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f56);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36042811));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 36042841));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2688, 36040704)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29922405));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 29922435));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1962, 29921280)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31522913));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 31522943));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2245, 31522816)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29920348));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 29920378));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 5221, 29917184)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32567874));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 53, 32567904));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 6297, 32567296)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32566237));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 32566267));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4674, 32563200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 32564659));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 32564689));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3037, 32563200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35154576));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 35154606));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3467, 35151872)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34420375));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 34420405));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2143, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34420831));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34420861));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2549, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34421573));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 34421603));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3344, 34418688)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34438470));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 63, 34438500));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3681, 34435072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36457841));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 36457871));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4242, 36454400)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35939717));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 35939747));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1726, 35938304)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 28356265));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 28356295));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4322, 28352512)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 29935078));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 50, 29935108));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1983, 29933568)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36467015));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f68 = TEMP_FAILURE_RETRY(open("file64", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 36467045));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1083, 36466688)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
TEMP_FAILURE_RETRY(read(t3532f68, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f68, buf, 16384));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f73 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f68, buf, 16384));
TEMP_FAILURE_RETRY(fdatasync(t3499f73));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34267550));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34267580));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f73);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 12, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(76)) return -1;
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 722, 34267136)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511105));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35511135));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3217, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511441));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35511471));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3780, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513993));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35514023));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2120, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513539));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35513569));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1673, 35512320)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3532f61 = TEMP_FAILURE_RETRY(open("file65", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f61);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f61 = TEMP_FAILURE_RETRY(open("file66", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3532f61 = TEMP_FAILURE_RETRY(open("file67", O_RDONLY|O_LARGEFILE));
t3499f62 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f62, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f62);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3533f61 = TEMP_FAILURE_RETRY(open("file68", O_RDONLY|O_LARGEFILE));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f62 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 512, 0));
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 512));
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 8716));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f62, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f61 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f61));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
TEMP_FAILURE_RETRY(pwrite(t3499f62, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f62));
t3532f61 = TEMP_FAILURE_RETRY(open("file69", O_RDONLY|O_LARGEFILE));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f62);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3532f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3532f61);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3533f61 = TEMP_FAILURE_RETRY(open("file70", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f61);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f61 = TEMP_FAILURE_RETRY(open("file71", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f61, buf, 16384));
TEMP_FAILURE_RETRY(read(t3519f61, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f61);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f80 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f80, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f80);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f80 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f80, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f80));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f81 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f81));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f81);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f80));
TEMP_FAILURE_RETRY(pwrite(t3499f80, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f80));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f80);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
t3499f68 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f68));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34957756));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 29, 34957786));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3273, 34955264)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f68 = TEMP_FAILURE_RETRY(open("file72", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file73", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file74", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file75", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file76", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file77", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file78", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file79", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file80", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file81", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file82", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f70 = TEMP_FAILURE_RETRY(open("file83", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file84", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file85", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file86", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file87", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file88", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file89", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file90", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file91", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file92", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file93", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file94", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file95", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f72 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f72, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f72);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3492f70 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f70, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3492f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3492f31, buf, 16, 24));
t3519f68 = TEMP_FAILURE_RETRY(open("file96", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file97", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file98", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file99", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file100", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file101", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file102", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file103", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file104", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file105", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file106", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file107", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file108", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f68 = TEMP_FAILURE_RETRY(open("file109", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f68);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f72 = TEMP_FAILURE_RETRY(open("file110", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f72);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f80 = TEMP_FAILURE_RETRY(open("file111", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f80);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f81 = TEMP_FAILURE_RETRY(open("file112", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f81);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f81 = TEMP_FAILURE_RETRY(open("file113", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f81);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f76 = TEMP_FAILURE_RETRY(open("file114", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f76);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file115", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file116", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f70 = TEMP_FAILURE_RETRY(open("file117", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f67 = TEMP_FAILURE_RETRY(open("file118", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file119", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file120", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file121", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file122", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file123", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file124", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(79)) return -1;
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file125", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file126", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file127", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3519f70 = TEMP_FAILURE_RETRY(open("file128", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f70 = TEMP_FAILURE_RETRY(open("file129", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
int t3519f75 = TEMP_FAILURE_RETRY(open("file128", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file129", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3519f75, buf, 2991));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f75);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f70, buf, 3974));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3519f67 = TEMP_FAILURE_RETRY(open("file130", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3519f67, buf, 16384));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f72 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f72, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f72);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3519f67, buf, 16384));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f72 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 8716));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f72, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f67 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f67));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f67);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f72);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file131", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file131", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f70, buf, 4622));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f72 = TEMP_FAILURE_RETRY(open("file132", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f72);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f72 = TEMP_FAILURE_RETRY(open("file132", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f72, buf, 16384));
TEMP_FAILURE_RETRY(write(t3526f72, buf, 6849));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f72);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file133", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f75 = TEMP_FAILURE_RETRY(open("file133", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f75, buf, 13332));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f75);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f70 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3495f70, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3495f70 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3495f70, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f75 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3495f75));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f75);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f70);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f93 = TEMP_FAILURE_RETRY(open("file134", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f93);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f88 = TEMP_FAILURE_RETRY(open("file134", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f88, buf, 15056));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f88);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34433108));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 56, 34433138));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2496, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34432434));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 50, 34432464));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1795, 34430976)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34431679));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 72, 34431709));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1083, 34430976)); // mmap2
t3495f75 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3495f75, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f75);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3495f75 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3495f75, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3495f75));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f86 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3495f86));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f86);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f75));
TEMP_FAILURE_RETRY(pwrite(t3495f75, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f75));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f75);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f74 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f74, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f74);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f74 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f74, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f74));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f75 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f75));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f75);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f74));
TEMP_FAILURE_RETRY(pwrite(t3499f74, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f74));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f74);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f64 = TEMP_FAILURE_RETRY(open("file135", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f64);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f64 = TEMP_FAILURE_RETRY(open("file135", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f64, buf, 16384));
TEMP_FAILURE_RETRY(write(t3526f64, buf, 4873));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f64);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f90 = TEMP_FAILURE_RETRY(open("file136", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f90 = TEMP_FAILURE_RETRY(open("file136", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f90, buf, 4199));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511105));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 28, 35511135));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3217, 35508224)); // mmap2
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35511441));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 40, 35511471));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3780, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35512004));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 35512034));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4299, 35508224)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f92 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513993));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 34, 35514023));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2120, 35512320)); // mmap2
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35513539));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 37, 35513569));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1673, 35512320)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
t3499f92 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(82)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
t3499f92 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f72 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3495f72, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f72);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f84 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f84, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f84);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f72 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 516));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f84 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 512));
TEMP_FAILURE_RETRY(pread(t3499f72, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4096, 516));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f88 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f88));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 4616));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f88);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 12, 0));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4096, 4620));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3495f84, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3495f84));
TEMP_FAILURE_RETRY(pwrite(t3499f72, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f88 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31156572));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58, 31156602));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3099, 31154176)); // mmap2
TEMP_FAILURE_RETRY(fdatasync(t3495f88));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f72);
close(t3495f88);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f84));
TEMP_FAILURE_RETRY(pwrite(t3495f84, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f84));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f84);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34907552));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 39, 34907582));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2551, 34906112)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3495f66 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3495f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3495f66 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3495f66, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3495f66));
t3495f72 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3495f72));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f72);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f66));
TEMP_FAILURE_RETRY(pwrite(t3495f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f66 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f66, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f70 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
TEMP_FAILURE_RETRY(pwrite(t3499f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f66);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f66 = TEMP_FAILURE_RETRY(open("file137", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3526f66, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f66, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f66);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3505f66 = TEMP_FAILURE_RETRY(open("file138", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3526f70 = TEMP_FAILURE_RETRY(open("file139", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3526f70, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f70, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f70, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 10432));
TEMP_FAILURE_RETRY(write(t3505f66, buf, 4464));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3495f70 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3495f70, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3495f70 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3495f70, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
t3495f72 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3495f72));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f72);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
TEMP_FAILURE_RETRY(pwrite(t3495f70, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3495f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3495f70);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 10592));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f70 = TEMP_FAILURE_RETRY(open("file140", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f70 = TEMP_FAILURE_RETRY(open("file140", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f70, buf, 4042));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f70);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 9664));
TEMP_FAILURE_RETRY(write(t3505f66, buf, 23656));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f70 = TEMP_FAILURE_RETRY(open("file141", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file142", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f72 = TEMP_FAILURE_RETRY(open("file141", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f70 = TEMP_FAILURE_RETRY(open("file142", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f70, buf, 5057));
TEMP_FAILURE_RETRY(write(t3533f72, buf, 4595));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f70);
close(t3533f72);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 19744));
TEMP_FAILURE_RETRY(write(t3505f66, buf, 9344));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f70 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f70, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f70);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f70 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f70, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f70));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 24672));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f72 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f72));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f72);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f70));
TEMP_FAILURE_RETRY(pwrite(t3499f70, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f70);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3505f66, buf, 7584));
TEMP_FAILURE_RETRY(write(t3505f66, buf, 10736));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 512, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(85)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 16924));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 16928));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 16932));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 21028));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 21032));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 21036));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 25132));
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 8, 25600));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f70 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3505f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3505f66 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3505f66, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
t3505f70 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3505f70));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f70);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
TEMP_FAILURE_RETRY(pwrite(t3505f66, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f66));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f66);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 36227657));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 38, 36227687));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3166, 36225024)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 30377994));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 33, 30378024));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4545, 30375936)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35333764));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 45, 35333794));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3019, 35332096)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34435036));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 34435066));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 324, 34435072)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34742552));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 34742582));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 602, 34742272)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31308722));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 42, 31308752));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3902, 31305728)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31307465));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 46, 31307495));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2994, 31305728)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31306529));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 41, 31306559));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1737, 31305728)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34261624));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 49, 34261654));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2993, 34258944)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f91 = TEMP_FAILURE_RETRY(open("file143", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f91);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f91 = TEMP_FAILURE_RETRY(open("file143", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31210525));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 31210555));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f91, buf, 16384));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3673, 31207424)); // mmap2
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f91, buf, 2024));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f91);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f91 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f91, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f91);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f91 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f91, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f91));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f93 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f93));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f93);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f91));
TEMP_FAILURE_RETRY(pwrite(t3499f91, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f91));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f91);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f84 = TEMP_FAILURE_RETRY(open("file31", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f84, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f84);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3505f84 = TEMP_FAILURE_RETRY(open("file31", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3505f84, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3505f84));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f90 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3505f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f84));
TEMP_FAILURE_RETRY(pwrite(t3505f84, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3505f84));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f84);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f102 = TEMP_FAILURE_RETRY(open("file144", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f102);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f72 = TEMP_FAILURE_RETRY(open("file144", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f72, buf, 5550));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f72);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f84 = TEMP_FAILURE_RETRY(open("file145", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f84);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f101 = TEMP_FAILURE_RETRY(open("file145", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f101, buf, 3612));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f101);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f90 = TEMP_FAILURE_RETRY(open("file146", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f90 = TEMP_FAILURE_RETRY(open("file146", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f90, buf, 5414));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f96 = TEMP_FAILURE_RETRY(open("file147", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f96);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f96 = TEMP_FAILURE_RETRY(open("file147", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f96, buf, 3834));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f96);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3519f90 = TEMP_FAILURE_RETRY(open("file148", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3519f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3519f90 = TEMP_FAILURE_RETRY(open("file148", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3519f90, buf, 3461));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3526f96 = TEMP_FAILURE_RETRY(open("file149", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f96);
close(t3519f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3526f90 = TEMP_FAILURE_RETRY(open("file149", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3526f90, buf, 16384));
TEMP_FAILURE_RETRY(write(t3526f90, buf, 12766));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f90 = TEMP_FAILURE_RETRY(open("file150", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f90 = TEMP_FAILURE_RETRY(open("file150", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f96 = TEMP_FAILURE_RETRY(open("file151", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 100, 0));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f90, buf, 10056));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3505f90 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 0));
t3505f90 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
t3505f90 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 8192));
t3505f90 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
t3505f90 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3533f99 = TEMP_FAILURE_RETRY(open("file153", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0600));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3533f90 = TEMP_FAILURE_RETRY(open("file153", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3533f90, buf, 13271));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 12288));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f99 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f99, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 147456));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 151552));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 196608));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 253952));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 303104));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 335872));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 450560));
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 4096, 495616));
t3505f99 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3505f99, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f96, buf, 16, 24));
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(88)) return -1;
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f90 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f90, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
t3499f92 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
TEMP_FAILURE_RETRY(pwrite(t3499f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34438470));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 63, 34438500));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3681, 34435072)); // mmap2
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3576f95 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3576f95, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3576f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f95 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f95));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
t3499f95 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f95));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 31156572));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58, 31156602));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3099, 31154176)); // mmap2
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3576f95 = TEMP_FAILURE_RETRY(open("file152", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3576f95, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3576f95);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f106 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f106));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f105 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
t3499f105 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f100 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f100, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
t3499f105 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
TEMP_FAILURE_RETRY(pwrite(t3499f100, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f100));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35636928));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 60, 35636958));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(91)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2062, 35635200)); // mmap2
t3499f84 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f84, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f84);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f27 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f27, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f27));
t3499f84 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f84));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f84);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f27));
TEMP_FAILURE_RETRY(pwrite(t3499f27, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f27));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f27);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f27 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f27, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f27);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
t3499f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f92 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3499f92, buf, 8, 17408));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
t3499f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
TEMP_FAILURE_RETRY(pwrite(t3499f92, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f92));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f92);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f92 = TEMP_FAILURE_RETRY(open("file154", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 0));
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 8192));
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34965811));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 34965841));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3053, 34963456)); // mmap2
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 12288));
t3545f97 = TEMP_FAILURE_RETRY(open("file156", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3545f97, buf, 8));
TEMP_FAILURE_RETRY(read(t3545f97, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f100 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f100, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 20480));
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
t3545f100 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3545f100));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f100);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f104 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f104, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f104);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f29 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f29, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
t3545f29 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f97, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3575f29 = TEMP_FAILURE_RETRY(open("file16", O_RDWR|O_CREAT|O_EXCL|O_LARGEFILE, 0));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3575f29, buf, 17344));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3575f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
t3545f29 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f29, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f29 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3545f29, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
t3545f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3545f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f26 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f26);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f26 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f26, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f26));
t3499f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f97));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(93)) return -1;
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f26));
TEMP_FAILURE_RETRY(pwrite(t3499f26, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f26));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f26);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f26 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f26, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f26);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f28 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f28, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
t3499f97 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f97));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f28);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3545f97 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f97, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f97);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f90 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 28672));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 36864));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 40960));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 45056));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 49152));
t3545f90 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
t3545f90 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
t3545f29 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f29, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f29 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3545f29, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
t3545f90 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3545f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f29, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f29));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f29);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f84 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f84, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f84);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f84 = TEMP_FAILURE_RETRY(open("file157", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f90 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3545f90 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 0));
TEMP_FAILURE_RETRY(pread(t3545f90, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f90 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 4, 12820));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f99 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f90, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3545f90));
TEMP_FAILURE_RETRY(pread(t3584f99, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f99 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3545f99));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f90));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 24576));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f90, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f90));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f29 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f29, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f29);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 8192));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f27 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f27, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f27);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3545f95 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3584f99 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3545f95, buf, 1, 0));
TEMP_FAILURE_RETRY(pread(t3584f99, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f95);
close(t3584f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 12288));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 32768));
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3545f99 = TEMP_FAILURE_RETRY(open("file155", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 8716));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f95 = TEMP_FAILURE_RETRY(open("file159", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3584f95, buf, 8));
TEMP_FAILURE_RETRY(read(t3584f95, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 12820));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 12824));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4096, 12828));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 16924));
TEMP_FAILURE_RETRY(pread(t3545f92, buf, 4096, 4096));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 16928));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4096, 16932));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 4, 21028));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3584f101 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f101, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f101);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 40960));
t3584f101 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3584f101, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f101);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 45056));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 49152));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 53248));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 57344));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 61440));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 65536));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 69632));
t3584f101 = TEMP_FAILURE_RETRY(open("file158", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3584f101, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3584f101);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3584f84, buf, 4096, 32768));
TEMP_FAILURE_RETRY(pread(t3545f99, buf, 8, 21504));
TEMP_FAILURE_RETRY(fdatasync(t3545f99));
t3545f95 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3545f95));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f99));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 0));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 4096));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 28672));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 32768));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 49152));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 53248));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 57344));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 61440));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 65536));
TEMP_FAILURE_RETRY(pwrite(t3545f92, buf, 4096, 69632));
TEMP_FAILURE_RETRY(fdatasync(t3545f92));
TEMP_FAILURE_RETRY(pwrite(t3545f99, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3545f99));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3545f99);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3581f99 = TEMP_FAILURE_RETRY(open("file155", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3581f99, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3581f99);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34970937));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 48, 34970967));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 3831, 34967552)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34291385));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 47, 34291415));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 4092, 34287616)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 30004037));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 30004067));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2007, 30003200)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35001738));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 44, 35001768));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 1840, 35000320)); // mmap2
t3533f90 = TEMP_FAILURE_RETRY(open("file160", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 1580859));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 1580889));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 60268, 1576960)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 35002160));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 36, 35002190));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2527, 35000320)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 34269564));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 55, 34269594));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 2753, 34267136)); // mmap2
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 30, 1637228));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 31, 1637258));
TEMP_FAILURE_RETRY(pread(t3455f17, buf, 58435, 1634304)); // mmap2
t3533f90 = TEMP_FAILURE_RETRY(open("file161", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3526f90 = TEMP_FAILURE_RETRY(open("file162", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(96)) return -1;
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3526f90 = TEMP_FAILURE_RETRY(open("file163", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3533f90 = TEMP_FAILURE_RETRY(open("file164", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3533f90, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3533f90);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3526f90 = TEMP_FAILURE_RETRY(open("file165", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
TEMP_FAILURE_RETRY(read(t3526f90, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3526f90);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3586f102 = TEMP_FAILURE_RETRY(open("file166", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3586f102);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3586f97 = TEMP_FAILURE_RETRY(open("file167", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3586f97, buf, 8192));
TEMP_FAILURE_RETRY(read(t3586f97, buf, 8192));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3586f97);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3587f95 = TEMP_FAILURE_RETRY(open("file168", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3587f95, buf, 16384));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3587f95);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f28 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f28, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f28);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3496f28 = TEMP_FAILURE_RETRY(open("file169", O_WRONLY|O_CREAT|O_TRUNC|O_LARGEFILE, 0600));
int t3499f103 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f103, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f103));
t3499f105 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3496f28, buf, 8188));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f103));
Fix copy/paste error in benchmark code. This had minimal impact on the results, since 95% of the writes were performed through pwrite(), but it's important to fix this for future benchmark suites. Bug: 29759783 Change-Id: Ic628aab98b9f9def78508cc722899afdefed84ae
2016-06-27 19:17:51 +02:00
TEMP_FAILURE_RETRY(write(t3496f28, buf, 3166));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f103, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f103));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f103);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fsync(t3496f28));
t3499f106 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f106);
close(t3496f28);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f28 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f28, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
t3499f105 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
TEMP_FAILURE_RETRY(pwrite(t3499f28, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f28));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f28);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3541f103 = TEMP_FAILURE_RETRY(open("file170", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3541f105 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 4096, 0));
t3541f105 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3541f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 16, 24));
t3541f105 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3541f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 4096, 8192));
t3541f105 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3541f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 16, 24));
t3541f105 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3541f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 4096, 12288));
t3541f105 = TEMP_FAILURE_RETRY(open("file172", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3541f105, buf, 8));
TEMP_FAILURE_RETRY(read(t3541f105, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f105);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3541f106 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3541f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3541f103, buf, 4096, 20480));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f107 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3499f107, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f107);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f107 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f107, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f107));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3499f108 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(fdatasync(t3499f108));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f108);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f107));
TEMP_FAILURE_RETRY(pwrite(t3499f107, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f107));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f107);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f107 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f107, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f107);
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
t3499f105 = TEMP_FAILURE_RETRY(open("file18", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0660));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 512, 0));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 512));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4096, 516));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 4612));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 4616));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4096, 4620));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 8716));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 8720));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4096, 8724));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 4, 12820));
TEMP_FAILURE_RETRY(pread(t3499f105, buf, 8, 13312));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
t3499f106 = TEMP_FAILURE_RETRY(open("file22", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(fdatasync(t3499f106));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 12, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
TEMP_FAILURE_RETRY(pwrite(t3499f105, buf, 28, 0));
TEMP_FAILURE_RETRY(fdatasync(t3499f105));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f105);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3505f106 = TEMP_FAILURE_RETRY(open("file171", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3505f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3505f106);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3540f107 = TEMP_FAILURE_RETRY(open("file173", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3540f108 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f108, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f108);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3540f105 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
t3540f105 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3540f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 8192));
t3540f105 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3540f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
t3540f105 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3540f105, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 12288));
t3540f105 = TEMP_FAILURE_RETRY(open("file175", O_RDONLY|O_LARGEFILE));
TEMP_FAILURE_RETRY(read(t3540f105, buf, 8));
TEMP_FAILURE_RETRY(read(t3540f105, buf, 1));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f105);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3540f106 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 24576));
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 4096, 20480));
t3540f106 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3540f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
t3540f106 = TEMP_FAILURE_RETRY(open("file174", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3540f106, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f106);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3540f107, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3496f105 = TEMP_FAILURE_RETRY(open("file176", O_RDONLY|O_LARGEFILE|O_DIRECTORY|O_CLOEXEC));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3496f105);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
t3499f108 = TEMP_FAILURE_RETRY(open("file18", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3499f108, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3499f108);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3597f108 = TEMP_FAILURE_RETRY(open("file177", O_RDWR|O_CREAT|O_LARGEFILE|O_CLOEXEC, 0600));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 100, 0));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3597f109 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f109, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f109);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 0));
t3597f109 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3597f109, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f109);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
t3597f109 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3597f109, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f109);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 8192));
t3597f109 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3597f109, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f109);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3540f109 = TEMP_FAILURE_RETRY(open("file179", O_RDONLY|O_LARGEFILE));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(read(t3540f109, buf, 4000));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3597f110 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f110, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f110);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3540f109);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(99)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 16384));
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 12288));
t3597f109 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
TEMP_FAILURE_RETRY(pread(t3597f109, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f109);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3597f111 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f111, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3597f111);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 16, 24));
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 24576));
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 20480));
TEMP_FAILURE_RETRY(pread(t3597f108, buf, 4096, 57344));
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
int t3598f111 = TEMP_FAILURE_RETRY(open("file178", O_RDONLY|O_LARGEFILE|O_CLOEXEC));
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
TEMP_FAILURE_RETRY(pread(t3598f111, buf, 1, 0));
Don't use TEMP_FAILURE_RETRY on close in vold. Bug: http://b/20501816 Change-Id: Ia0a3899947582b8dd0e8e185c203d1ad7dad572e
2015-05-29 07:02:14 +02:00
close(t3598f111);
close(t3540f107);
close(t3541f103);
close(t3545f92);
close(t3492f31);
close(t3505f96);
close(t3433f17);
close(t3597f108);
close(t3584f84);
close(t3455f17);
close(t3483f25);
close(t3483f20);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
free(buf);
return 0;
}
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
static status_t CreateFile(const char* name, int len) {
int chunk = std::min(len, 65536);
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
int out = -1;
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
std::string buf;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
if (android::vold::ReadRandomBytes(chunk, buf) != OK) {
LOG(ERROR) << "Failed to read random data";
return -EIO;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
}
Cleanup uses of sprintf, add modes to open() with O_CREAT. Change-Id: Iaed2538831b19ada26005bbef33cff28209c6512
2016-02-29 22:39:17 +01:00
if ((out = TEMP_FAILURE_RETRY(open(name, O_WRONLY|O_CREAT|O_TRUNC, 0644))) < 0) {
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
PLOG(ERROR) << "Failed to open " << name;
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
return -errno;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
}
while (len > 0) {
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
int n = write(out, buf.c_str(), std::min(len, chunk));
if (n < 0) {
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
PLOG(ERROR) << "Failed to write";
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
close(out);
return -errno;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
}
len -= n;
}
close(out);
Use random data for benchmark instead of zeros. If we always write zeros, we're leaving a giant pile of known plaintext at an almost deterministic location on newly formatted volumes. To avoid this, repeat a 64K chunk of random data. Bug: 22816936 Change-Id: Iedc067a519bd676a93b9d74ea4f9f77c84c8461c
2015-07-29 18:14:21 +02:00
return OK;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
}
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
static status_t BenchmarkCreate(std::function<bool(int)> checkpoint) {
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
status_t res = 0;
res |= CreateFile("stub", 0);
res |= CreateFile("file115", 0);
res |= CreateFile("file125", 0);
res |= CreateFile("file43", 49152);
res |= CreateFile("file2", 57016320);
res |= CreateFile("file17", 176128);
res |= CreateFile("file126", 0);
res |= CreateFile("file4", 0);
res |= CreateFile("file175", 9);
res |= CreateFile("file76", 0);
res |= CreateFile("file140", 4042);
res |= CreateFile("file80", 0);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(3)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file139", 49152);
res |= CreateFile("file50", 32768);
res |= CreateFile("file179", 4000);
res |= CreateFile("file144", 5550);
res |= CreateFile("file138", 130888);
res |= CreateFile("file28", 3182276);
res |= CreateFile("file161", 32768);
res |= CreateFile("file34", 1423);
res |= CreateFile("file53", 32768);
res |= CreateFile("file72", 0);
res |= CreateFile("file55", 16384);
res |= CreateFile("file54", 39938);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(6)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file129", 3974);
res |= CreateFile("file107", 0);
res |= CreateFile("file95", 0);
res |= CreateFile("file82", 0);
res |= CreateFile("file27", 53280);
res |= CreateFile("file167", 16384);
res |= CreateFile("file9", 24588);
res |= CreateFile("file123", 0);
res |= CreateFile("file89", 0);
res |= CreateFile("file40", 4172);
res |= CreateFile("file20", 1);
res |= CreateFile("file151", 499712);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(10)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file106", 0);
res |= CreateFile("file159", 9);
res |= CreateFile("file47", 32768);
res |= CreateFile("file146", 5414);
res |= CreateFile("file153", 13271);
res |= CreateFile("file12", 2);
res |= CreateFile("file137", 32768);
res |= CreateFile("file157", 73728);
res |= CreateFile("file172", 9);
res |= CreateFile("file148", 3461);
res |= CreateFile("file7", 794976);
res |= CreateFile("file68", 32768);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(13)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file109", 0);
res |= CreateFile("file142", 5057);
res |= CreateFile("file147", 3834);
res |= CreateFile("file117", 0);
res |= CreateFile("file94", 0);
res |= CreateFile("file81", 0);
res |= CreateFile("file75", 0);
res |= CreateFile("file111", 0);
res |= CreateFile("file105", 0);
res |= CreateFile("file79", 0);
res |= CreateFile("file65", 32768);
res |= CreateFile("file135", 21257);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(16)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file124", 0);
res |= CreateFile("file87", 0);
res |= CreateFile("file64", 49152);
res |= CreateFile("file131", 4622);
res |= CreateFile("file130", 32768);
res |= CreateFile("file59", 143552);
res |= CreateFile("file141", 4595);
res |= CreateFile("file149", 29150);
res |= CreateFile("file178", 1);
res |= CreateFile("file163", 32768);
res |= CreateFile("file67", 32768);
res |= CreateFile("file155", 21512);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(20)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file156", 9);
res |= CreateFile("file23", 28700);
res |= CreateFile("file61", 32768);
res |= CreateFile("file0", 40464617);
res |= CreateFile("file39", 32768);
res |= CreateFile("file145", 3612);
res |= CreateFile("file70", 32768);
res |= CreateFile("file69", 32768);
res |= CreateFile("file24", 94220);
res |= CreateFile("file57", 32768);
res |= CreateFile("file104", 0);
res |= CreateFile("file113", 0);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(23)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file99", 0);
res |= CreateFile("file120", 0);
res |= CreateFile("file154", 73728);
res |= CreateFile("file127", 0);
res |= CreateFile("file38", 65720);
res |= CreateFile("file77", 0);
res |= CreateFile("file85", 0);
res |= CreateFile("file119", 0);
res |= CreateFile("file96", 0);
res |= CreateFile("file91", 0);
res |= CreateFile("file158", 1);
res |= CreateFile("file174", 1);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(26)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file48", 32768);
res |= CreateFile("file33", 32566);
res |= CreateFile("file83", 0);
res |= CreateFile("file32", 179192);
res |= CreateFile("file118", 0);
res |= CreateFile("file121", 0);
res |= CreateFile("file101", 0);
res |= CreateFile("file168", 16384);
res |= CreateFile("file16", 31392);
res |= CreateFile("file164", 32768);
res |= CreateFile("file36", 192544);
res |= CreateFile("file6", 4636);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(30)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file10", 16484);
res |= CreateFile("file150", 10056);
res |= CreateFile("file62", 32768);
res |= CreateFile("file165", 32768);
res |= CreateFile("file42", 28736);
res |= CreateFile("file19", 188416);
res |= CreateFile("file128", 2991);
res |= CreateFile("file112", 0);
res |= CreateFile("file100", 0);
res |= CreateFile("file103", 0);
res |= CreateFile("file26", 28676);
res |= CreateFile("file46", 32768);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(33)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file60", 32768);
res |= CreateFile("file162", 32768);
res |= CreateFile("file25", 32872);
res |= CreateFile("file21", 16384);
res |= CreateFile("file45", 32768);
res |= CreateFile("file3", 0);
res |= CreateFile("file171", 1);
res |= CreateFile("file15", 2);
res |= CreateFile("file51", 32768);
res |= CreateFile("file37", 159752);
res |= CreateFile("file73", 0);
res |= CreateFile("file71", 32768);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(36)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file98", 0);
res |= CreateFile("file74", 0);
res |= CreateFile("file93", 0);
res |= CreateFile("file122", 0);
res |= CreateFile("file143", 18408);
res |= CreateFile("file8", 20648);
res |= CreateFile("file152", 1);
res |= CreateFile("file66", 32768);
res |= CreateFile("file136", 4199);
res |= CreateFile("file132", 23233);
res |= CreateFile("file92", 0);
res |= CreateFile("file11", 0);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(40)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file86", 0);
res |= CreateFile("file22", 0);
res |= CreateFile("file56", 16384);
res |= CreateFile("file78", 0);
res |= CreateFile("file41", 32768);
res |= CreateFile("file110", 0);
res |= CreateFile("file90", 0);
res |= CreateFile("file44", 12328);
res |= CreateFile("file63", 49152);
res |= CreateFile("file116", 0);
res |= CreateFile("file29", 1035);
res |= CreateFile("file35", 118788);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(43)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file170", 24576);
res |= CreateFile("file30", 98304);
res |= CreateFile("file14", 0);
res |= CreateFile("file160", 32768);
res |= CreateFile("file176", 0);
res |= CreateFile("file1", 471040);
res |= CreateFile("file108", 0);
res |= CreateFile("file173", 28672);
res |= CreateFile("file18", 17416);
res |= CreateFile("file134", 15056);
res |= CreateFile("file31", 25608);
res |= CreateFile("file97", 0);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(46)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file84", 0);
res |= CreateFile("file114", 0);
res |= CreateFile("file88", 0);
res |= CreateFile("file102", 0);
res |= CreateFile("file58", 32768);
res |= CreateFile("file52", 49152);
res |= CreateFile("file13", 0);
res |= CreateFile("file5", 41168);
res |= CreateFile("file133", 13332);
res |= CreateFile("file169", 11354);
res |= CreateFile("file166", 0);
res |= CreateFile("file49", 32768);
Abort long-running benchmarks, report progress. A typical storage device finishes the benchmark in under 10 seconds, but some extremely slow devices can take minutes, resulting in a confusing UX that looks like we've frozen. Even worse, we keep churning through all that I/O even though we know the device will blow past our user-warning threshold. So periodically check if we've timed out, and also use that to report progress up into the Settings UI. Test: manual Bug: 62201209, 65639764, 67055204 Change-Id: I321397bcff230976f034cede0947d4a5a1f3e8a7
2017-11-06 21:53:59 +01:00
if (!checkpoint(50)) return -1;
Initial pass at storage benchmarks. Now that we're offering to store private app data on adopted storage devices, the performance of those devices is much more important to overall user experience. To help set user expectations, this change offers to execute a real-world benchmark on a storage device, returning a metric that can be used to compare internal and external storage. The benchmark is generated from the strace-instrumented storage access patterns of typical apps. A typical device completes the benchmark in under two seconds on internal storage, a UHS-3 SD card is even faster (!), but a very slow Class 4 SD card takes about 30 seconds to complete, giving us a clear signal. The measured benchmark numbers are logged along with information about the storage device, such as manufacturer, model, etc. Card serial numbers are scrubbed from output. Bug: 21172095 Change-Id: I9b2713dafdfdfcf5d97bf1bc21841f39409a7e54
2015-05-15 05:33:55 +02:00
res |= CreateFile("file177", 61440);
return res;
}
static status_t BenchmarkDestroy() {
status_t res = 0;
res |= unlink("stub");
res |= unlink("file115");
res |= unlink("file125");
res |= unlink("file43");
res |= unlink("file2");
res |= unlink("file17");
res |= unlink("file126");
res |= unlink("file4");
res |= unlink("file175");
res |= unlink("file76");
res |= unlink("file140");
res |= unlink("file80");
res |= unlink("file139");
res |= unlink("file50");
res |= unlink("file179");
res |= unlink("file144");
res |= unlink("file138");
res |= unlink("file28");
res |= unlink("file161");
res |= unlink("file34");
res |= unlink("file53");
res |= unlink("file72");
res |= unlink("file55");
res |= unlink("file54");
res |= unlink("file129");
res |= unlink("file107");
res |= unlink("file95");
res |= unlink("file82");
res |= unlink("file27");
res |= unlink("file167");
res |= unlink("file9");
res |= unlink("file123");
res |= unlink("file89");
res |= unlink("file40");
res |= unlink("file20");
res |= unlink("file151");
res |= unlink("file106");
res |= unlink("file159");
res |= unlink("file47");
res |= unlink("file146");
res |= unlink("file153");
res |= unlink("file12");
res |= unlink("file137");
res |= unlink("file157");
res |= unlink("file172");
res |= unlink("file148");
res |= unlink("file7");
res |= unlink("file68");
res |= unlink("file109");
res |= unlink("file142");
res |= unlink("file147");
res |= unlink("file117");
res |= unlink("file94");
res |= unlink("file81");
res |= unlink("file75");
res |= unlink("file111");
res |= unlink("file105");
res |= unlink("file79");
res |= unlink("file65");
res |= unlink("file135");
res |= unlink("file124");
res |= unlink("file87");
res |= unlink("file64");
res |= unlink("file131");
res |= unlink("file130");
res |= unlink("file59");
res |= unlink("file141");
res |= unlink("file149");
res |= unlink("file178");
res |= unlink("file163");
res |= unlink("file67");
res |= unlink("file155");
res |= unlink("file156");
res |= unlink("file23");
res |= unlink("file61");
res |= unlink("file0");
res |= unlink("file39");
res |= unlink("file145");
res |= unlink("file70");
res |= unlink("file69");
res |= unlink("file24");
res |= unlink("file57");
res |= unlink("file104");
res |= unlink("file113");
res |= unlink("file99");
res |= unlink("file120");
res |= unlink("file154");
res |= unlink("file127");
res |= unlink("file38");
res |= unlink("file77");
res |= unlink("file85");
res |= unlink("file119");
res |= unlink("file96");
res |= unlink("file91");
res |= unlink("file158");
res |= unlink("file174");
res |= unlink("file48");
res |= unlink("file33");
res |= unlink("file83");
res |= unlink("file32");
res |= unlink("file118");
res |= unlink("file121");
res |= unlink("file101");
res |= unlink("file168");
res |= unlink("file16");
res |= unlink("file164");
res |= unlink("file36");
res |= unlink("file6");
res |= unlink("file10");
res |= unlink("file150");
res |= unlink("file62");
res |= unlink("file165");
res |= unlink("file42");
res |= unlink("file19");
res |= unlink("file128");
res |= unlink("file112");
res |= unlink("file100");
res |= unlink("file103");
res |= unlink("file26");
res |= unlink("file46");
res |= unlink("file60");
res |= unlink("file162");
res |= unlink("file25");
res |= unlink("file21");
res |= unlink("file45");
res |= unlink("file3");
res |= unlink("file171");
res |= unlink("file15");
res |= unlink("file51");
res |= unlink("file37");
res |= unlink("file73");
res |= unlink("file71");
res |= unlink("file98");
res |= unlink("file74");
res |= unlink("file93");
res |= unlink("file122");
res |= unlink("file143");
res |= unlink("file8");
res |= unlink("file152");
res |= unlink("file66");
res |= unlink("file136");
res |= unlink("file132");
res |= unlink("file92");
res |= unlink("file11");
res |= unlink("file86");
res |= unlink("file22");
res |= unlink("file56");
res |= unlink("file78");
res |= unlink("file41");
res |= unlink("file110");
res |= unlink("file90");
res |= unlink("file44");
res |= unlink("file63");
res |= unlink("file116");
res |= unlink("file29");
res |= unlink("file35");
res |= unlink("file170");
res |= unlink("file30");
res |= unlink("file14");
res |= unlink("file160");
res |= unlink("file176");
res |= unlink("file1");
res |= unlink("file108");
res |= unlink("file173");
res |= unlink("file18");
res |= unlink("file134");
res |= unlink("file31");
res |= unlink("file97");
res |= unlink("file84");
res |= unlink("file114");
res |= unlink("file88");
res |= unlink("file102");
res |= unlink("file58");
res |= unlink("file52");
res |= unlink("file13");
res |= unlink("file5");
res |= unlink("file133");
res |= unlink("file169");
res |= unlink("file166");
res |= unlink("file49");
res |= unlink("file177");
return res;
}
static std::string BenchmarkIdent() {
return "r1572:w1001:s285";
}
} // namespace vold
} // namespace android
Add mode flags to open calls with O_CREAT. Change-Id: Ib9fb61155d15ed9eb54942959af965df2fe21b71
2016-02-25 00:55:55 +01:00
Reference in a new issue Copy permalink