| /* |
| * Copyright (C) 2013 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. |
| */ |
| |
| #include "bandwidth.h" |
| |
| #include <ctype.h> |
| #include <pthread.h> |
| #include <sched.h> |
| #include <sys/resource.h> |
| #include <sys/time.h> |
| #include <unistd.h> |
| |
| #include <map> |
| #include <vector> |
| |
| |
| typedef struct { |
| const char *name; |
| bool int_type; |
| } option_t; |
| |
| option_t bandwidth_opts[] = { |
| { "size", true }, |
| { "num_warm_loops", true }, |
| { "num_loops", true }, |
| { "type", false }, |
| { NULL, false }, |
| }; |
| |
| option_t per_core_opts[] = { |
| { "size", true }, |
| { "num_warm_loops", true}, |
| { "num_loops", true }, |
| { "type", false }, |
| { NULL, false }, |
| }; |
| |
| option_t multithread_opts[] = { |
| { "size", true }, |
| { "num_warm_loops", true}, |
| { "num_loops", true }, |
| { "type", false }, |
| { "num_threads", true }, |
| { NULL, false }, |
| }; |
| |
| typedef union { |
| int int_value; |
| const char *char_value; |
| } arg_value_t; |
| typedef std::map<const char*, arg_value_t> arg_t; |
| |
| bool processBandwidthOptions(int argc, char** argv, option_t options[], |
| arg_t *values) { |
| for (int i = 1; i < argc; i++) { |
| if (argv[i][0] == '-' && argv[i][1] == '-' && !isdigit(argv[i][2])) { |
| char *arg = &argv[i][2]; |
| |
| for (int j = 0; options[j].name != NULL; j++) { |
| if (strcmp(arg, options[j].name) == 0) { |
| const char *name = options[j].name; |
| if (i == argc - 1) { |
| printf("The option --%s requires an argument.\n", name); |
| return false; |
| } |
| if (options[j].int_type) { |
| (*values)[name].int_value = strtol(argv[++i], NULL, 0); |
| } else { |
| (*values)[name].char_value = argv[++i]; |
| } |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| BandwidthBenchmark *createBandwidthBenchmarkObject(arg_t values) { |
| BandwidthBenchmark *bench = NULL; |
| |
| const char *name = values["type"].char_value; |
| size_t size = 0; |
| if (values.count("size") > 0) { |
| size = values["size"].int_value; |
| } |
| if (strcmp(name, "copy_ldrd_strd") == 0) { |
| bench = new CopyLdrdStrdBenchmark(); |
| } else if (strcmp(name, "copy_ldmia_stmia") == 0) { |
| bench = new CopyLdmiaStmiaBenchmark(); |
| } else if (strcmp(name, "copy_vld1_vst1") == 0) { |
| bench = new CopyVld1Vst1Benchmark(); |
| } else if (strcmp(name, "copy_vldr_vstr") == 0) { |
| bench = new CopyVldrVstrBenchmark(); |
| } else if (strcmp(name, "copy_vldmia_vstmia") == 0) { |
| bench = new CopyVldmiaVstmiaBenchmark(); |
| } else if (strcmp(name, "memcpy") == 0) { |
| bench = new MemcpyBenchmark(); |
| } else if (strcmp(name, "write_strd") == 0) { |
| bench = new WriteStrdBenchmark(); |
| } else if (strcmp(name, "write_stmia") == 0) { |
| bench = new WriteStmiaBenchmark(); |
| } else if (strcmp(name, "write_vst1") == 0) { |
| bench = new WriteVst1Benchmark(); |
| } else if (strcmp(name, "write_vstr") == 0) { |
| bench = new WriteVstrBenchmark(); |
| } else if (strcmp(name, "write_vstmia") == 0) { |
| bench = new WriteVstmiaBenchmark(); |
| } else if (strcmp(name, "memset") == 0) { |
| bench = new MemsetBenchmark(); |
| } else if (strcmp(name, "read_ldrd") == 0) { |
| bench = new ReadLdrdBenchmark(); |
| } else if (strcmp(name, "read_ldmia") == 0) { |
| bench = new ReadLdmiaBenchmark(); |
| } else if (strcmp(name, "read_vld1") == 0) { |
| bench = new ReadVld1Benchmark(); |
| } else if (strcmp(name, "read_vldr") == 0) { |
| bench = new ReadVldrBenchmark(); |
| } else if (strcmp(name, "read_vldmia") == 0) { |
| bench = new ReadVldmiaBenchmark(); |
| } else { |
| printf("Unknown type name %s\n", name); |
| return NULL; |
| } |
| |
| if (!bench->setSize(size)) { |
| printf("Failed to allocate buffers for benchmark.\n"); |
| delete bench; |
| return NULL; |
| } |
| |
| if (values.count("num_warm_loops") > 0) { |
| bench->set_num_loops(values["num_warm_loops"].int_value); |
| } |
| if (values.count("num_loops") > 0) { |
| bench->set_num_loops(values["num_loops"].int_value); |
| } |
| |
| return bench; |
| } |
| |
| bool getAvailCpus(std::vector<int> *cpu_list) { |
| cpu_set_t cpuset; |
| |
| CPU_ZERO(&cpuset); |
| if (sched_getaffinity(0, sizeof(cpuset), &cpuset) != 0) { |
| perror("sched_getaffinity failed."); |
| return false; |
| } |
| |
| for (int i = 0; i < CPU_SETSIZE; i++) { |
| if (CPU_ISSET(i, &cpuset)) { |
| cpu_list->push_back(i); |
| } |
| } |
| |
| return true; |
| } |
| |
| typedef struct { |
| int core; |
| BandwidthBenchmark *bench; |
| double avg_mb; |
| volatile bool *run; |
| } thread_arg_t; |
| |
| void *runBandwidthThread(void *data) { |
| thread_arg_t *arg = reinterpret_cast<thread_arg_t *>(data); |
| |
| if (arg->core >= 0) { |
| cpu_set_t cpuset; |
| CPU_ZERO(&cpuset); |
| CPU_SET(arg->core, &cpuset); |
| if (sched_setaffinity(0, sizeof(cpuset), &cpuset) != 0) { |
| perror("sched_setaffinity failed"); |
| return NULL; |
| } |
| } |
| |
| // Spinloop waiting for the run variable to get set to true. |
| while (!*arg->run) { |
| } |
| |
| double avg_mb = 0; |
| for (int run = 1; ; run++) { |
| arg->bench->run(); |
| if (!*arg->run) { |
| // Throw away the last data point since it's possible not |
| // all of the threads are running at this point. |
| break; |
| } |
| avg_mb = (avg_mb/run) * (run-1) + arg->bench->mb_per_sec()/run; |
| } |
| arg->avg_mb = avg_mb; |
| |
| return NULL; |
| } |
| |
| bool processThreadArgs(int argc, char** argv, option_t options[], |
| arg_t *values) { |
| // Use some smaller values for the number of loops. |
| (*values)["num_warm_loops"].int_value = 1000000; |
| (*values)["num_loops"].int_value = 10000000; |
| |
| if (!processBandwidthOptions(argc, argv, options, values)) { |
| return false; |
| } |
| if (values->count("size") > 0 && ((*values)["size"].int_value % 64) != 0) { |
| printf("The size values must be a multiple of 64.\n"); |
| return false; |
| } |
| if (values->count("type") == 0) { |
| printf("Must specify the type value.\n"); |
| return false; |
| } |
| |
| BandwidthBenchmark *bench = createBandwidthBenchmarkObject(*values); |
| if (!bench) { |
| return false; |
| } |
| |
| if (setpriority(PRIO_PROCESS, 0, -20)) { |
| perror("Unable to raise priority of process."); |
| return false; |
| } |
| |
| printf("Calculating optimum run time...\n"); |
| nsecs_t t = system_time(); |
| bench->run(); |
| t = system_time() - t; |
| // Since this is only going to be running single threaded, assume that |
| // if the number is set to ten times this value, we should get at least |
| // a couple of samples per thread. |
| int run_time = int((t/1000000000.0)*10 + 0.5) + 5; |
| |
| (*values)["run_time"].int_value = run_time; |
| (*values)["size"].int_value = bench->size(); |
| (*values)["num_warm_loops"].int_value = bench->num_warm_loops(); |
| (*values)["num_loops"].int_value = bench->num_loops(); |
| delete bench; |
| |
| return true; |
| } |
| |
| bool runThreadedTest(thread_arg_t args[], int num_threads, int run_time) { |
| pthread_t threads[num_threads]; |
| volatile bool run = false; |
| |
| int rc; |
| for (int i = 0; i < num_threads; i++) { |
| args[i].run = &run; |
| rc = pthread_create(&threads[i], NULL, runBandwidthThread, |
| (void*)&args[i]); |
| if (rc != 0) { |
| printf("Failed to launch thread %d\n", i); |
| return false; |
| } |
| } |
| |
| // Kick start the threads. |
| run = true; |
| |
| // Let the threads run. |
| sleep(run_time); |
| |
| // Stop the threads. |
| run = false; |
| |
| // Wait for the threads to complete. |
| for (int i = 0; i < num_threads; i++) { |
| rc = pthread_join(threads[i], NULL); |
| if (rc != 0) { |
| printf("Thread %d failed to join.\n", i); |
| return false; |
| } |
| printf("Thread %d: bandwidth using %s %0.2f MB/s\n", i, |
| args[i].bench->getName(), args[i].avg_mb); |
| } |
| |
| return true; |
| } |
| |
| int per_core_bandwidth(int argc, char** argv) { |
| arg_t values; |
| if (!processThreadArgs(argc, argv, per_core_opts, &values)) { |
| return -1; |
| } |
| |
| std::vector<int> cpu_list; |
| if (!getAvailCpus(&cpu_list)) { |
| printf("Failed to get available cpu list.\n"); |
| return -1; |
| } |
| |
| thread_arg_t args[cpu_list.size()]; |
| |
| int i = 0; |
| for (std::vector<int>::iterator it = cpu_list.begin(); |
| it != cpu_list.end(); ++it, ++i) { |
| args[i].core = *it; |
| args[i].bench = createBandwidthBenchmarkObject(values); |
| if (!args[i].bench) { |
| for (int j = 0; j < i; j++) |
| delete args[j].bench; |
| return -1; |
| } |
| } |
| |
| printf("Running on %d cores\n", cpu_list.size()); |
| printf(" run_time = %ds\n", values["run_time"].int_value); |
| printf(" size = %d\n", values["size"].int_value); |
| printf(" num_warm_loops = %d\n", values["num_warm_loops"].int_value); |
| printf(" num_loops = %d\n", values["num_loops"].int_value); |
| printf("\n"); |
| |
| if (!runThreadedTest(args, cpu_list.size(), values["run_time"].int_value)) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| int multithread_bandwidth(int argc, char** argv) { |
| arg_t values; |
| if (!processThreadArgs(argc, argv, multithread_opts, &values)) { |
| return -1; |
| } |
| if (values.count("num_threads") == 0) { |
| printf("Must specify the num_threads value.\n"); |
| return -1; |
| } |
| int num_threads = values["num_threads"].int_value; |
| |
| thread_arg_t args[num_threads]; |
| |
| for (int i = 0; i < num_threads; i++) { |
| args[i].core = -1; |
| args[i].bench = createBandwidthBenchmarkObject(values); |
| if (!args[i].bench) { |
| for (int j = 0; j < i; j++) |
| delete args[j].bench; |
| return -1; |
| } |
| } |
| |
| printf("Running %d threads\n", num_threads); |
| printf(" run_time = %ds\n", values["run_time"].int_value); |
| printf(" size = %d\n", values["size"].int_value); |
| printf(" num_warm_loops = %d\n", values["num_warm_loops"].int_value); |
| printf(" num_loops = %d\n", values["num_loops"].int_value); |
| printf("\n"); |
| |
| if (!runThreadedTest(args, num_threads, values["run_time"].int_value)) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| bool run_bandwidth_benchmark(int argc, char** argv, const char *name, |
| std::vector<BandwidthBenchmark*> bench_objs) { |
| arg_t values; |
| values["size"].int_value = 0; |
| values["num_warm_loops"].int_value = 0; |
| values["num_loops"].int_value = 0; |
| if (!processBandwidthOptions(argc, argv, bandwidth_opts, &values)) { |
| return false; |
| } |
| |
| size_t size = values["size"].int_value; |
| if ((size % 64) != 0) { |
| printf("The size value must be a multiple of 64.\n"); |
| return false; |
| } |
| |
| if (setpriority(PRIO_PROCESS, 0, -20)) { |
| perror("Unable to raise priority of process."); |
| return false; |
| } |
| |
| bool preamble_printed = false; |
| size_t num_warm_loops = values["num_warm_loops"].int_value; |
| size_t num_loops = values["num_loops"].int_value; |
| for (std::vector<BandwidthBenchmark*>::iterator it = bench_objs.begin(); |
| it != bench_objs.end(); ++it) { |
| if (!(*it)->canRun()) { |
| continue; |
| } |
| if (!(*it)->setSize(values["size"].int_value)) { |
| printf("Failed creating buffer for bandwidth test.\n"); |
| return false; |
| } |
| if (num_warm_loops) { |
| (*it)->set_num_warm_loops(num_warm_loops); |
| } |
| if (num_loops) { |
| (*it)->set_num_loops(num_loops); |
| } |
| if (!preamble_printed) { |
| preamble_printed = true; |
| printf("Benchmarking %s bandwidth\n", name); |
| printf(" size = %d\n", (*it)->size()); |
| printf(" num_warm_loops = %d\n", (*it)->num_warm_loops()); |
| printf(" num_loops = %d\n\n", (*it)->num_loops()); |
| } |
| (*it)->run(); |
| printf(" %s bandwidth with %s: %0.2f MB/s\n", name, (*it)->getName(), |
| (*it)->mb_per_sec()); |
| } |
| |
| return true; |
| } |
| |
| int copy_bandwidth(int argc, char** argv) { |
| std::vector<BandwidthBenchmark*> bench_objs; |
| bench_objs.push_back(new CopyLdrdStrdBenchmark()); |
| bench_objs.push_back(new CopyLdmiaStmiaBenchmark()); |
| bench_objs.push_back(new CopyVld1Vst1Benchmark()); |
| bench_objs.push_back(new CopyVldrVstrBenchmark()); |
| bench_objs.push_back(new CopyVldmiaVstmiaBenchmark()); |
| bench_objs.push_back(new MemcpyBenchmark()); |
| |
| if (!run_bandwidth_benchmark(argc, argv, "copy", bench_objs)) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| int write_bandwidth(int argc, char** argv) { |
| std::vector<BandwidthBenchmark*> bench_objs; |
| bench_objs.push_back(new WriteStrdBenchmark()); |
| bench_objs.push_back(new WriteStmiaBenchmark()); |
| bench_objs.push_back(new WriteVst1Benchmark()); |
| bench_objs.push_back(new WriteVstrBenchmark()); |
| bench_objs.push_back(new WriteVstmiaBenchmark()); |
| bench_objs.push_back(new MemsetBenchmark()); |
| |
| if (!run_bandwidth_benchmark(argc, argv, "write", bench_objs)) { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| int read_bandwidth(int argc, char** argv) { |
| std::vector<BandwidthBenchmark*> bench_objs; |
| bench_objs.push_back(new ReadLdrdBenchmark()); |
| bench_objs.push_back(new ReadLdmiaBenchmark()); |
| bench_objs.push_back(new ReadVld1Benchmark()); |
| bench_objs.push_back(new ReadVldrBenchmark()); |
| bench_objs.push_back(new ReadVldmiaBenchmark()); |
| |
| if (!run_bandwidth_benchmark(argc, argv, "read", bench_objs)) { |
| return -1; |
| } |
| return 0; |
| } |
