Skip to content

L
libcifpp
Commit 85dfdf41 by Maarten L. Hekkelman
Options

Better progress bar

parent 505f0fdd
Showing with 155 additions and 140 deletions
include/cif++/utilities.hpp
...@@ -157,11 +157,11 @@ inline auto coloured(std::basic_string<CharT, Traits, Alloc> &s, StringColour fo ...@@ -157,11 +157,11 @@ inline auto coloured(std::basic_string<CharT, Traits, Alloc> &s, StringColour fo
// -------------------------------------------------------------------- // --------------------------------------------------------------------
// A progress bar // A progress bar
class Progress class progress_bar
{ {
public: public:
Progress(int64_t inMax, const std::string &inAction); progress_bar(int64_t inMax, const std::string &inAction);
virtual ~Progress(); ~progress_bar();
void consumed(int64_t inConsumed); // consumed is relative void consumed(int64_t inConsumed); // consumed is relative
void progress(int64_t inProgress); // progress is absolute void progress(int64_t inProgress); // progress is absolute
...@@ -169,10 +169,10 @@ class Progress ...@@ -169,10 +169,10 @@ class Progress
void message(const std::string &inMessage); void message(const std::string &inMessage);
private: private:
Progress(const Progress &) = delete; progress_bar(const progress_bar &) = delete;
Progress &operator=(const Progress &) = delete; progress_bar &operator=(const progress_bar &) = delete;
struct ProgressImpl *m_impl; struct progress_bar_impl *m_impl;
}; };
// -------------------------------------------------------------------- // --------------------------------------------------------------------
......
src/utilities.cpp
...@@ -31,6 +31,7 @@ ...@@ -31,6 +31,7 @@
#include <atomic> #include <atomic>
#include <cassert> #include <cassert>
#include <cmath> #include <cmath>
#include <condition_variable>
#include <cstring> #include <cstring>
#include <deque> #include <deque>
#include <fstream> #include <fstream>
...@@ -135,41 +136,41 @@ std::string get_executable_path() ...@@ -135,41 +136,41 @@ std::string get_executable_path()
// -------------------------------------------------------------------- // --------------------------------------------------------------------
struct ProgressImpl struct progress_bar_impl
{ {
ProgressImpl(int64_t inMax, const std::string &inAction) progress_bar_impl(int64_t inMax, const std::string &inAction)
: mMax(inMax) : m_max_value(inMax)
, mConsumed(0) , m_consumed(0)
, mAction(inAction) , m_action(inAction)
, mMessage(inAction) , m_message(inAction)
, mThread(std::bind(&ProgressImpl::Run, this)) , m_thread(std::bind(&progress_bar_impl::run, this))
{ {
} }
void Run(); void run();
void Stop() void stop();
{
mStop = true;
if (mThread.joinable())
mThread.join();
}
void PrintProgress(); void consumed(int64_t n);
void PrintDone(); void progress(int64_t p);
void message(const std::string &msg);
int64_t mMax; void print_progress();
std::atomic<int64_t> mConsumed; void print_done();
int64_t mLastConsumed = 0;
int mSpinnerIndex = 0; int64_t m_max_value;
std::string mAction, mMessage; std::atomic<int64_t> m_consumed;
std::mutex mMutex; int64_t m_last_consumed = 0;
std::thread mThread; int m_spinner_index = 0;
std::string m_action, m_message;
std::mutex m_mutex;
std::thread m_thread;
std::condition_variable m_cv;
std::chrono::time_point<std::chrono::system_clock> std::chrono::time_point<std::chrono::system_clock>
mStart = std::chrono::system_clock::now(); m_start = std::chrono::system_clock::now();
bool mStop = false; bool m_stop = false;
}; };
void ProgressImpl::Run() void progress_bar_impl::run()
{ {
using namespace std::literals; using namespace std::literals;
...@@ -179,19 +180,21 @@ void ProgressImpl::Run() ...@@ -179,19 +180,21 @@ void ProgressImpl::Run()
{ {
for (;;) for (;;)
{ {
std::this_thread::sleep_for(10ms); std::unique_lock lock(m_mutex);
std::unique_lock lock(mMutex); m_cv.wait_for(lock, 100ms);
if (mStop or mConsumed == mMax) if (m_stop or m_consumed >= m_max_value)
break; break;
auto elapsed = std::chrono::system_clock::now() - mStart; if (std::chrono::system_clock::now() - m_start < 2s)
if (elapsed < std::chrono::seconds(5))
continue; continue;
if (not printedAny and isatty(STDOUT_FILENO))
fputs("\e[?25l", stdout);
print_progress();
PrintProgress();
printedAny = true; printedAny = true;
} }
} }
...@@ -200,93 +203,114 @@ void ProgressImpl::Run() ...@@ -200,93 +203,114 @@ void ProgressImpl::Run()
} }
if (printedAny) if (printedAny)
PrintDone(); {
print_done();
if (isatty(STDOUT_FILENO))
fputs("\e[?25h", stdout);
}
} }
void ProgressImpl::PrintProgress() void progress_bar_impl::stop()
{ {
// const char* kBlocks[] = { {
// " ", // 0 std::unique_lock lock(m_mutex);
// u8"\u258F", // 1
// u8"\u258E", // 2 m_stop = true;
// u8"\u258D", // 3 m_cv.notify_one();
// u8"\u258C", // 4 }
// u8"\u258B", // 5
// u8"\u258A", // 6 if (m_thread.joinable())
// u8"\u2589", // 7 m_thread.join();
// u8"\u2588", // 8 }
// };
void progress_bar_impl::consumed(int64_t n)
{
std::unique_lock lock(m_mutex);
m_consumed += n;
m_cv.notify_one();
}
void progress_bar_impl::progress(int64_t p)
{
std::unique_lock lock(m_mutex);
m_consumed = p;
m_cv.notify_one();
}
void progress_bar_impl::message(const std::string &msg)
{
std::unique_lock lock(m_mutex);
m_message = msg;
m_cv.notify_one();
}
const char* kSpinner[] = {
// "▉", "▊", "▋", "▌", "▍", "▎", "▏", "▎", "▍", "▌", "▋", "▊", "▉"
".", "o", "O", "0", "O", "o", ".", " "
};
const size_t kSpinnerCount = sizeof(kSpinner) / sizeof(char*);
const uint32_t kMinBarWidth = 40, kMinMsgWidth = 12;
void progress_bar_impl::print_progress()
{
const char *kBlocks[] = { const char *kBlocks[] = {
" ", // 0 // "▯", // 0
" ", // 1 // "▮", // 1
" ", // 2 "=",
"-", // 3 "-"
"-", // 4
"-", // 5
"=", // 6
"=", // 7
"=", // 8
}; };
uint32_t width = get_terminal_width(); uint32_t width = get_terminal_width();
std::string msg; float progress = static_cast<float>(m_consumed) / m_max_value;
msg.reserve(width + 1);
if (mMessage.length() <= 20) if (width < kMinBarWidth)
{ std::cout << (100 * progress) << '%' << std::endl;
msg = mMessage;
if (msg.length() < 20)
msg.append(20 - msg.length(), ' ');
}
else else
msg = mMessage.substr(0, 17) + "..."; {
uint32_t bar_width = 7 * width / 10;
uint32_t pct_width = 7;
uint32_t msg_width = width - bar_width - pct_width - 1;
msg += " |"; if (msg_width < kMinMsgWidth)
{
bar_width += kMinMsgWidth - msg_width;
msg_width = kMinMsgWidth;
}
int64_t consumed = mConsumed; std::ostringstream msg;
float progress = static_cast<float>(consumed) / mMax;
int pi = static_cast<int>(std::ceil(progress * 33 * 8));
// int tw = width - 28;
// int twd = static_cast<int>(tw * progress + 0.5f);
// msg.append(twd, '=');
// msg.append(tw - twd, ' ');
for (int i = 0; i < 33; ++i) if (m_message.length() <= msg_width)
{ {
if (pi <= 0) msg << m_message;
msg += kBlocks[0]; if (m_message.length() < msg_width)
else if (pi >= 8) msg << std::string(msg_width - m_message.length(), ' ');
msg += kBlocks[8]; }
else else
msg += kBlocks[pi]; msg << m_message.substr(0, msg_width - 3) << "...";
pi -= 8;
}
msg.append("| "); msg << ' ';
const char kSpinner[] = {' ', '.', 'o', 'O', '0', 'O', 'o', '.'}; uint32_t pi = static_cast<uint32_t>(std::ceil(progress * bar_width));
const size_t kSpinnerCount = sizeof(kSpinner);
if (mLastConsumed < consumed) for (uint32_t i = 0; i < bar_width; ++i)
{ msg << kBlocks[i > pi ? 1 : 0];
mLastConsumed = consumed;
mSpinnerIndex = (mSpinnerIndex + 1) % kSpinnerCount; msg << ' ';
}
msg << std::setw(3) << static_cast<int>(std::ceil(progress * 100)) << "% ";
const char spinner[2] = {kSpinner[mSpinnerIndex], 0}; auto now = std::chrono::system_clock::now();
msg.append(spinner); m_spinner_index = (std::chrono::duration_cast<std::chrono::milliseconds>(now - m_start).count() / 200) % kSpinnerCount;
// int perc = static_cast<int>(100 * progress); msg << kSpinner[m_spinner_index];
// if (perc < 100)
// msg += ' ';
// if (perc < 10)
// msg += ' ';
// msg += to_string(perc);
// msg += '%';
std::cout << '\r' << msg; std::cout << '\r' << msg.str();
std::cout.flush(); std::cout.flush();
}
} }
namespace namespace
...@@ -325,12 +349,12 @@ namespace ...@@ -325,12 +349,12 @@ namespace
} // namespace } // namespace
void ProgressImpl::PrintDone() void progress_bar_impl::print_done()
{ {
std::chrono::duration<double> elapsed = std::chrono::system_clock::now() - mStart; std::chrono::duration<double> elapsed = std::chrono::system_clock::now() - m_start;
std::ostringstream msgstr; std::ostringstream msgstr;
msgstr << mAction << " done in " << elapsed << " seconds"; msgstr << m_action << " done in " << elapsed << " seconds";
auto msg = msgstr.str(); auto msg = msgstr.str();
uint32_t width = get_terminal_width(); uint32_t width = get_terminal_width();
...@@ -341,46 +365,37 @@ void ProgressImpl::PrintDone() ...@@ -341,46 +365,37 @@ void ProgressImpl::PrintDone()
std::cout << '\r' << msg << std::endl; std::cout << '\r' << msg << std::endl;
} }
Progress::Progress(int64_t inMax, const std::string &inAction) progress_bar::progress_bar(int64_t inMax, const std::string &inAction)
: m_impl(nullptr) : m_impl(nullptr)
{ {
if (isatty(STDOUT_FILENO) and VERBOSE >= 0) if (isatty(STDOUT_FILENO) and VERBOSE >= 0)
m_impl = new ProgressImpl(inMax, inAction); m_impl = new progress_bar_impl(inMax, inAction);
} }
Progress::~Progress() progress_bar::~progress_bar()
{ {
if (m_impl != nullptr) if (m_impl != nullptr)
m_impl->Stop(); m_impl->stop();
delete m_impl; delete m_impl;
} }
void Progress::consumed(int64_t inConsumed) void progress_bar::consumed(int64_t inConsumed)
{ {
if (m_impl != nullptr and if (m_impl != nullptr)
(m_impl->mConsumed += inConsumed) >= m_impl->mMax) m_impl->consumed(inConsumed);
{
m_impl->Stop();
}
} }
void Progress::progress(int64_t inProgress) void progress_bar::progress(int64_t inProgress)
{ {
if (m_impl != nullptr and if (m_impl != nullptr)
(m_impl->mConsumed = inProgress) >= m_impl->mMax) m_impl->progress(inProgress);
{
m_impl->Stop();
}
} }
void Progress::message(const std::string &inMessage) void progress_bar::message(const std::string &inMessage)
{ {
if (m_impl != nullptr) if (m_impl != nullptr)
{ m_impl->message(inMessage);
std::unique_lock lock(m_impl->mMutex);
m_impl->mMessage = inMessage;
}
} }
} // namespace cif } // namespace cif
...@@ -822,12 +837,12 @@ namespace cif ...@@ -822,12 +837,12 @@ namespace cif
// -------------------------------------------------------------------- // --------------------------------------------------------------------
class ResourcePool class resource_pool
{ {
public: public:
static ResourcePool &instance() static resource_pool &instance()
{ {
static std::unique_ptr<ResourcePool> s_instance(new ResourcePool); static std::unique_ptr<resource_pool> s_instance(new resource_pool);
return *s_instance; return *s_instance;
} }
...@@ -857,7 +872,7 @@ class ResourcePool ...@@ -857,7 +872,7 @@ class ResourcePool
std::unique_ptr<std::istream> load(fs::path name); std::unique_ptr<std::istream> load(fs::path name);
private: private:
ResourcePool(); resource_pool();
std::unique_ptr<std::ifstream> open(fs::path &p) std::unique_ptr<std::ifstream> open(fs::path &p)
{ {
...@@ -883,7 +898,7 @@ class ResourcePool ...@@ -883,7 +898,7 @@ class ResourcePool
std::deque<fs::path> mDirs; std::deque<fs::path> mDirs;
}; };
ResourcePool::ResourcePool() resource_pool::resource_pool()
{ {
#if defined(DATA_DIR) #if defined(DATA_DIR)
pushDir(DATA_DIR); pushDir(DATA_DIR);
...@@ -900,7 +915,7 @@ ResourcePool::ResourcePool() ...@@ -900,7 +915,7 @@ ResourcePool::ResourcePool()
#endif #endif
} }
std::unique_ptr<std::istream> ResourcePool::load(fs::path name) std::unique_ptr<std::istream> resource_pool::load(fs::path name)
{ {
std::unique_ptr<std::istream> result; std::unique_ptr<std::istream> result;
std::error_code ec; std::error_code ec;
...@@ -932,17 +947,17 @@ std::unique_ptr<std::istream> ResourcePool::load(fs::path name) ...@@ -932,17 +947,17 @@ std::unique_ptr<std::istream> ResourcePool::load(fs::path name)
void add_data_directory(std::filesystem::path dataDir) void add_data_directory(std::filesystem::path dataDir)
{ {
ResourcePool::instance().pushDir(dataDir); resource_pool::instance().pushDir(dataDir);
} }
void add_file_resource(const std::string &name, std::filesystem::path dataFile) void add_file_resource(const std::string &name, std::filesystem::path dataFile)
{ {
ResourcePool::instance().pushAlias(name, dataFile); resource_pool::instance().pushAlias(name, dataFile);
} }
std::unique_ptr<std::istream> load_resource(std::filesystem::path name) std::unique_ptr<std::istream> load_resource(std::filesystem::path name)
{ {
return ResourcePool::instance().load(name); return resource_pool::instance().load(name);
} }
} // namespace cif } // namespace cif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment