git.sesse.net Git - nageru/blob - futatabi/frame_on_disk.cpp

   1 #include "frame_on_disk.h"
   2
   3 #include "shared/metrics.h"
   4
   5 #include <atomic>
   6 #include <chrono>
   7 #include <fcntl.h>
   8 #include <mutex>
   9 #include <unistd.h>
  10
  11 using namespace std;
  12 using namespace std::chrono;
  13
  14 namespace {
  15
  16 // There can be multiple FrameReader classes, so make all the metrics static.
  17 once_flag frame_metrics_inited;
  18
  19 atomic<int64_t> metric_frame_opened_files{ 0 };
  20 atomic<int64_t> metric_frame_closed_files{ 0 };
  21 atomic<int64_t> metric_frame_read_bytes{ 0 };
  22 atomic<int64_t> metric_frame_read_frames{ 0 };
  23
  24 Summary metric_frame_read_time_seconds;
  25
  26 }  // namespace
  27
  28 FrameReader::FrameReader()
  29 {
  30         call_once(frame_metrics_inited, [] {
  31                 global_metrics.add("frame_opened_files", &metric_frame_opened_files);
  32                 global_metrics.add("frame_closed_files", &metric_frame_closed_files);
  33                 global_metrics.add("frame_read_bytes", &metric_frame_read_bytes);
  34                 global_metrics.add("frame_read_frames", &metric_frame_read_frames);
  35
  36                 vector<double> quantiles{ 0.01, 0.1, 0.25, 0.5, 0.75, 0.9, 0.99 };
  37                 metric_frame_read_time_seconds.init(quantiles, 60.0);
  38                 global_metrics.add("frame_read_time_seconds", &metric_frame_read_time_seconds);
  39         });
  40 }
  41
  42 FrameReader::~FrameReader()
  43 {
  44         if (fd != -1) {
  45                 close(fd);
  46                 ++metric_frame_closed_files;
  47         }
  48 }
  49
  50 string FrameReader::read_frame(FrameOnDisk frame)
  51 {
  52         steady_clock::time_point start = steady_clock::now();
  53
  54         if (int(frame.filename_idx) != last_filename_idx) {
  55                 if (fd != -1) {
  56                         close(fd);  // Ignore errors.
  57                         ++metric_frame_closed_files;
  58                 }
  59
  60                 string filename;
  61                 {
  62                         lock_guard<mutex> lock(frame_mu);
  63                         filename = frame_filenames[frame.filename_idx];
  64                 }
  65
  66                 fd = open(filename.c_str(), O_RDONLY);
  67                 if (fd == -1) {
  68                         perror(filename.c_str());
  69                         abort();
  70                 }
  71
  72                 // We want readahead. (Ignore errors.)
  73                 posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
  74
  75                 last_filename_idx = frame.filename_idx;
  76                 ++metric_frame_opened_files;
  77         }
  78
  79         // TODO: Read the audio.
  80
  81         string str;
  82         str.resize(frame.size);
  83         off_t offset = 0;
  84         while (offset < frame.size) {
  85                 int ret = pread(fd, &str[offset], frame.size - offset, frame.offset + offset);
  86                 if (ret <= 0) {
  87                         string filename = frame_filenames[frame.filename_idx];
  88                         perror("pread");
  89                         abort();
  90                 }
  91
  92                 offset += ret;
  93         }
  94
  95         steady_clock::time_point stop = steady_clock::now();
  96         metric_frame_read_time_seconds.count_event(duration<double>(stop - start).count());
  97
  98         metric_frame_read_bytes += frame.size;
  99         ++metric_frame_read_frames;
 100
 101         return str;
 102 }