2022-10-25 16:13:08 +00:00
|
|
|
#include "whisper.h"
|
|
|
|
|
|
|
|
#include <cstdio>
|
2023-09-18 07:51:10 +00:00
|
|
|
#include <cstring>
|
2022-10-25 16:13:08 +00:00
|
|
|
#include <string>
|
|
|
|
#include <thread>
|
|
|
|
|
|
|
|
// command-line parameters
|
|
|
|
struct whisper_params {
|
2022-11-25 17:08:51 +00:00
|
|
|
int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
|
2023-01-18 18:31:46 +00:00
|
|
|
int32_t what = 0; // what to benchmark: 0 - whisper ecoder, 1 - memcpy, 2 - ggml_mul_mat
|
2022-10-25 16:13:08 +00:00
|
|
|
|
2022-11-25 17:08:51 +00:00
|
|
|
std::string model = "models/ggml-base.en.bin";
|
2023-11-06 09:04:24 +00:00
|
|
|
|
|
|
|
bool use_gpu = true;
|
2022-10-25 16:13:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void whisper_print_usage(int argc, char ** argv, const whisper_params & params);
|
|
|
|
|
|
|
|
bool whisper_params_parse(int argc, char ** argv, whisper_params & params) {
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
|
|
std::string arg = argv[i];
|
|
|
|
|
2022-11-25 17:08:51 +00:00
|
|
|
if (arg == "-h" || arg == "--help") {
|
2022-10-25 16:13:08 +00:00
|
|
|
whisper_print_usage(argc, argv, params);
|
|
|
|
exit(0);
|
2022-11-25 17:08:51 +00:00
|
|
|
}
|
2023-11-06 09:04:24 +00:00
|
|
|
else if (arg == "-t" || arg == "--threads") { params.n_threads = std::stoi(argv[++i]); }
|
|
|
|
else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
|
|
|
|
else if (arg == "-w" || arg == "--what") { params.what = atoi(argv[++i]); }
|
|
|
|
else if (arg == "-ng" || arg == "--no-gpu") { params.use_gpu = false; }
|
2022-11-25 17:08:51 +00:00
|
|
|
else {
|
2022-10-25 16:13:08 +00:00
|
|
|
fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
|
|
|
|
whisper_print_usage(argc, argv, params);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-12-19 18:45:08 +00:00
|
|
|
void whisper_print_usage(int /*argc*/, char ** argv, const whisper_params & params) {
|
2022-10-25 16:13:08 +00:00
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "usage: %s [options]\n", argv[0]);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "options:\n");
|
2022-11-25 17:08:51 +00:00
|
|
|
fprintf(stderr, " -h, --help [default] show this help message and exit\n");
|
|
|
|
fprintf(stderr, " -t N, --threads N [%-7d] number of threads to use during computation\n", params.n_threads);
|
|
|
|
fprintf(stderr, " -m FNAME, --model FNAME [%-7s] model path\n", params.model.c_str());
|
2023-01-18 18:31:46 +00:00
|
|
|
fprintf(stderr, " -w N, --what N [%-7d] what to benchmark:\n", params.what);
|
2023-11-06 09:04:24 +00:00
|
|
|
fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU\n", params.use_gpu ? "false" : "true");
|
2023-09-15 09:18:18 +00:00
|
|
|
fprintf(stderr, " %-7s 0 - whisper\n", "");
|
2023-01-18 18:31:46 +00:00
|
|
|
fprintf(stderr, " %-7s 1 - memcpy\n", "");
|
|
|
|
fprintf(stderr, " %-7s 2 - ggml_mul_mat\n", "");
|
2022-10-25 16:13:08 +00:00
|
|
|
fprintf(stderr, "\n");
|
|
|
|
}
|
|
|
|
|
2023-09-15 09:18:18 +00:00
|
|
|
int whisper_bench_full(const whisper_params & params) {
|
2022-10-25 16:13:08 +00:00
|
|
|
// whisper init
|
|
|
|
|
2024-02-11 14:39:12 +00:00
|
|
|
struct whisper_context_params cparams = whisper_context_default_params();
|
2023-11-06 09:04:24 +00:00
|
|
|
cparams.use_gpu = params.use_gpu;
|
|
|
|
|
|
|
|
struct whisper_context * ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
|
2022-10-25 16:13:08 +00:00
|
|
|
|
2022-10-27 14:22:10 +00:00
|
|
|
{
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "system_info: n_threads = %d / %d | %s\n", params.n_threads, std::thread::hardware_concurrency(), whisper_print_system_info());
|
|
|
|
}
|
|
|
|
|
2022-10-25 16:13:08 +00:00
|
|
|
if (ctx == nullptr) {
|
|
|
|
fprintf(stderr, "error: failed to initialize whisper context\n");
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2023-11-07 13:30:18 +00:00
|
|
|
const int n_mels = whisper_model_n_mels(ctx);
|
|
|
|
|
|
|
|
if (int ret = whisper_set_mel(ctx, nullptr, 0, n_mels)) {
|
2022-10-25 16:13:08 +00:00
|
|
|
fprintf(stderr, "error: failed to set mel: %d\n", ret);
|
|
|
|
return 3;
|
|
|
|
}
|
2023-09-15 09:18:18 +00:00
|
|
|
// heat encoder
|
|
|
|
if (int ret = whisper_encode(ctx, 0, params.n_threads) != 0) {
|
2023-11-15 14:12:52 +00:00
|
|
|
fprintf(stderr, "error: failed to encode: %d\n", ret);
|
2023-09-15 09:18:18 +00:00
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
whisper_token tokens[512];
|
|
|
|
memset(tokens, 0, sizeof(tokens));
|
|
|
|
|
|
|
|
// prompt heat
|
|
|
|
if (int ret = whisper_decode(ctx, tokens, 256, 0, params.n_threads) != 0) {
|
2023-11-15 14:12:52 +00:00
|
|
|
fprintf(stderr, "error: failed to decode: %d\n", ret);
|
2023-09-15 09:18:18 +00:00
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
// text-generation heat
|
|
|
|
if (int ret = whisper_decode(ctx, tokens, 1, 256, params.n_threads) != 0) {
|
2023-11-15 14:12:52 +00:00
|
|
|
fprintf(stderr, "error: failed to decode: %d\n", ret);
|
2023-09-15 09:18:18 +00:00
|
|
|
return 4;
|
|
|
|
}
|
2022-10-25 16:13:08 +00:00
|
|
|
|
2023-09-15 09:18:18 +00:00
|
|
|
whisper_reset_timings(ctx);
|
|
|
|
|
|
|
|
// actual run
|
2022-10-25 16:13:08 +00:00
|
|
|
if (int ret = whisper_encode(ctx, 0, params.n_threads) != 0) {
|
2023-11-15 14:12:52 +00:00
|
|
|
fprintf(stderr, "error: failed to encode: %d\n", ret);
|
2022-10-25 16:13:08 +00:00
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
|
2023-11-15 14:12:52 +00:00
|
|
|
// text-generation
|
|
|
|
for (int i = 0; i < 256; i++) {
|
|
|
|
if (int ret = whisper_decode(ctx, tokens, 1, i, params.n_threads) != 0) {
|
|
|
|
fprintf(stderr, "error: failed to decode: %d\n", ret);
|
2023-09-15 09:18:18 +00:00
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-15 14:12:52 +00:00
|
|
|
// batched decoding
|
|
|
|
for (int i = 0; i < 64; i++) {
|
|
|
|
if (int ret = whisper_decode(ctx, tokens, 5, 0, params.n_threads) != 0) {
|
|
|
|
fprintf(stderr, "error: failed to decode: %d\n", ret);
|
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// prompt processing
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
|
|
if (int ret = whisper_decode(ctx, tokens, 256, 0, params.n_threads) != 0) {
|
|
|
|
fprintf(stderr, "error: failed to decode: %d\n", ret);
|
2023-09-15 09:18:18 +00:00
|
|
|
return 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-25 16:13:08 +00:00
|
|
|
whisper_print_timings(ctx);
|
|
|
|
whisper_free(ctx);
|
|
|
|
|
2022-10-25 17:18:26 +00:00
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "If you wish, you can submit these results here:\n");
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, " https://github.com/ggerganov/whisper.cpp/issues/89\n");
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, "Please include the following information:\n");
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
fprintf(stderr, " - CPU model\n");
|
|
|
|
fprintf(stderr, " - Operating system\n");
|
|
|
|
fprintf(stderr, " - Compiler\n");
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
2022-10-25 16:13:08 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2023-01-18 18:31:46 +00:00
|
|
|
|
|
|
|
int main(int argc, char ** argv) {
|
|
|
|
whisper_params params;
|
|
|
|
|
|
|
|
if (whisper_params_parse(argc, argv, params) == false) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
switch (params.what) {
|
2023-09-15 09:18:18 +00:00
|
|
|
case 0: ret = whisper_bench_full(params); break;
|
2023-01-18 19:00:41 +00:00
|
|
|
case 1: ret = whisper_bench_memcpy(params.n_threads); break;
|
|
|
|
case 2: ret = whisper_bench_ggml_mul_mat(params.n_threads); break;
|
2023-01-18 18:31:46 +00:00
|
|
|
default: fprintf(stderr, "error: unknown benchmark: %d\n", params.what); break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|