From: Chris Lattner Date: Wed, 31 Dec 2003 05:40:02 +0000 (+0000) Subject: New class, useful for command-line interactive programs. X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=a2e9363617a77b7ada49759676d464bdf373cc69;p=oota-llvm.git New class, useful for command-line interactive programs. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10662 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/Support/SlowOperationInformer.h b/include/Support/SlowOperationInformer.h new file mode 100644 index 00000000000..f27a05571b4 --- /dev/null +++ b/include/Support/SlowOperationInformer.h @@ -0,0 +1,56 @@ +//===- SlowOperationInformer.h - Keep the user informed ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines a simple object which can be used to let the user know what +// is going on when a slow operation is happening,l and gives them the ability +// to cancel it. Potentially slow operations can stack allocate one of these +// objects, and periodically call the "progress" method to update the progress +// bar. If the operation takes more than 3 seconds to complete, the progress +// bar is automatically shown and updated every second. As such, the slow +// operation should not print stuff to the screen, and should not be confused if +// an extra line appears on the screen (ie, the cursor should be at the start of +// the line). +// +// If the user presses CTRL-C during the operation, the next invocation of the +// progress method with throw an std::string object indicating that the +// operation was cancelled. As such, client code must be exception safe around +// the progress method. +// +// Because SlowOperationInformers fiddle around with signals, they cannot be +// nested. The SIGINT signal handler is restored after the +// SlowOperationInformer is destroyed, but the SIGALRM handlers is set back to +// the default. +// +//===----------------------------------------------------------------------===// + +#ifndef SUPPORT_SLOW_OPERATION_INFORMER_H +#define SUPPORT_SLOW_OPERATION_INFORMER_H + +#include + +namespace llvm { + class SlowOperationInformer { + std::string OperationName; + unsigned LastPrintAmount; + + SlowOperationInformer(const SlowOperationInformer&); // DO NOT IMPLEMENT + void operator=(const SlowOperationInformer&); // DO NOT IMPLEMENT + public: + SlowOperationInformer(const std::string &Name); + ~SlowOperationInformer(); + + /// progress - Clients should periodically call this method when they are in + /// an exception-safe state. The Amount variable should indicate how far + /// along the operation is, given in 1/10ths of a percent (in other words, + /// Amount should range from 0 to 1000). + void progress(unsigned Amount); + }; +} // end namespace llvm + +#endif /* SLOW_OPERATION_INFORMER_H */ diff --git a/include/llvm/Support/SlowOperationInformer.h b/include/llvm/Support/SlowOperationInformer.h new file mode 100644 index 00000000000..f27a05571b4 --- /dev/null +++ b/include/llvm/Support/SlowOperationInformer.h @@ -0,0 +1,56 @@ +//===- SlowOperationInformer.h - Keep the user informed ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines a simple object which can be used to let the user know what +// is going on when a slow operation is happening,l and gives them the ability +// to cancel it. Potentially slow operations can stack allocate one of these +// objects, and periodically call the "progress" method to update the progress +// bar. If the operation takes more than 3 seconds to complete, the progress +// bar is automatically shown and updated every second. As such, the slow +// operation should not print stuff to the screen, and should not be confused if +// an extra line appears on the screen (ie, the cursor should be at the start of +// the line). +// +// If the user presses CTRL-C during the operation, the next invocation of the +// progress method with throw an std::string object indicating that the +// operation was cancelled. As such, client code must be exception safe around +// the progress method. +// +// Because SlowOperationInformers fiddle around with signals, they cannot be +// nested. The SIGINT signal handler is restored after the +// SlowOperationInformer is destroyed, but the SIGALRM handlers is set back to +// the default. +// +//===----------------------------------------------------------------------===// + +#ifndef SUPPORT_SLOW_OPERATION_INFORMER_H +#define SUPPORT_SLOW_OPERATION_INFORMER_H + +#include + +namespace llvm { + class SlowOperationInformer { + std::string OperationName; + unsigned LastPrintAmount; + + SlowOperationInformer(const SlowOperationInformer&); // DO NOT IMPLEMENT + void operator=(const SlowOperationInformer&); // DO NOT IMPLEMENT + public: + SlowOperationInformer(const std::string &Name); + ~SlowOperationInformer(); + + /// progress - Clients should periodically call this method when they are in + /// an exception-safe state. The Amount variable should indicate how far + /// along the operation is, given in 1/10ths of a percent (in other words, + /// Amount should range from 0 to 1000). + void progress(unsigned Amount); + }; +} // end namespace llvm + +#endif /* SLOW_OPERATION_INFORMER_H */ diff --git a/lib/Support/SlowOperationInformer.cpp b/lib/Support/SlowOperationInformer.cpp new file mode 100644 index 00000000000..40759f6d487 --- /dev/null +++ b/lib/Support/SlowOperationInformer.cpp @@ -0,0 +1,94 @@ +//===-- SlowOperationInformer.cpp - Keep the user informed ----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the SlowOperationInformer class for the LLVM debugger. +// +//===----------------------------------------------------------------------===// + +#include "Support/SlowOperationInformer.h" +#include "Config/config.h" // Get the signal handler return type +#include +#include +#include +#include +using namespace llvm; + +/// OperationCancelled - This flag is set by the SIGINT signal handler if the +/// user presses CTRL-C. +static volatile bool OperationCancelled; + +/// ShouldShowStatus - This flag gets set if the operation takes a long time. +/// +static volatile bool ShouldShowStatus; + +/// NestedSOI - Sanity check. SlowOperationInformers cannot be nested or run in +/// parallel. This ensures that they never do. +static bool NestedSOI = false; + +static RETSIGTYPE SigIntHandler(int Sig) { + OperationCancelled = true; + signal(SIGINT, SigIntHandler); +} + +static RETSIGTYPE SigAlarmHandler(int Sig) { + ShouldShowStatus = true; +} + +static sighandler_t OldSigIntHandler; + + +SlowOperationInformer::SlowOperationInformer(const std::string &Name) + : OperationName(Name), LastPrintAmount(0) { + assert(!NestedSOI && "SlowerOperationInformer objects cannot be nested!"); + NestedSOI = true; + + OperationCancelled = 0; + ShouldShowStatus = 0; + + signal(SIGALRM, SigAlarmHandler); + OldSigIntHandler = signal(SIGINT, SigIntHandler); + alarm(1); +} + +SlowOperationInformer::~SlowOperationInformer() { + NestedSOI = false; + if (LastPrintAmount) + std::cout << "\n"; + + alarm(0); + signal(SIGALRM, SIG_DFL); + signal(SIGINT, OldSigIntHandler); +} + +/// progress - Clients should periodically call this method when they are in +/// an exception-safe state. The Amount variable should indicate how far +/// along the operation is, given in 1/10ths of a percent (in other words, +/// Amount should range from 0 to 1000). +void SlowOperationInformer::progress(unsigned Amount) { + if (OperationCancelled) { + std::cout << "\n"; + LastPrintAmount = 0; + throw "While " + OperationName + ", operation cancelled."; + } + + // If we haven't spent enough time in this operation to warrant displaying the + // progress bar, don't do so yet. + if (!ShouldShowStatus) + return; + + // Delete whatever we printed last time. + std::string ToPrint = std::string(LastPrintAmount, '\b'); + + std::ostringstream OS; + OS << "Progress " << OperationName << ": " << Amount/10 << "." << Amount % 10 + << "%"; + + LastPrintAmount = OS.str().size(); + std::cout << ToPrint+OS.str() << std::flush; +}