def _iteration_parameters(image_rows,
image_cols,
row_block_size,
col_block_size,
y_overlap=0,
x_overlap=0,
bands=1):
maximum_blocks = 0
for i in range(0, image_rows, row_block_size - y_overlap):
for j in range(0, image_cols, col_block_size - x_overlap):
if bands > 1:
for band in range(1, bands + 1):
maximum_blocks += 1
else:
maximum_blocks += 1
progress_widgets = [
' Percent: ',
widgets.Percentage(), ' ',
widgets.Bar(marker='*', left='[', right=']'), ' ',
widgets.ETA(), ' ',
widgets.FileTransferSpeed()
]
progress_bar = ProgressBar(widgets=progress_widgets, maxval=maximum_blocks)
progress_bar.start()
return 1, progress_bar
def progressbar_count_widgets(pbar: ProgressBar):
from progressbar import widgets
if pbar.max_value:
return [
widgets.Percentage(**pbar.widget_kwargs),
' ',
widgets.SimpleProgress(format="({value:,} of {max_value:,})",
new_style=True,
**pbar.widget_kwargs),
' ',
widgets.Bar(**pbar.widget_kwargs),
' ',
widgets.Timer(**pbar.widget_kwargs),
]
else:
return [
widgets.AnimatedMarker(**pbar.widget_kwargs),
' ',
widgets.BouncingBar(**pbar.widget_kwargs),
' ',
widgets.Counter(**pbar.widget_kwargs),
' ',
widgets.Timer(**pbar.widget_kwargs),
]
async def show_progresses_offline(self):
from progressbar import ProgressBar, widgets
barformat_notfinalized = [
widgets.AnimatedMarker(), ' ', widgets.Counter(), ' ',
widgets.BouncingBar(), ' ', widgets.Timer()]
class LooseAdaptiveETA(widgets.AdaptiveETA):
# Stabilize the ETA on results from large batches rushes in
NUM_SAMPLES = 100
barformat_finalized = [
widgets.AnimatedMarker(), ' ', widgets.Percentage(), ' of ',
widgets.FormatLabel('%(max)d'), ' ', widgets.Bar(), ' ',
widgets.Timer('Elapsed: %s'), ' ', LooseAdaptiveETA()]
self.pbar = ProgressBar(widgets=barformat_notfinalized)
self.pbar.start()
notfinalized = True
while self.running:
if notfinalized and self.scan_finished:
notfinalized = False
self.pbar = ProgressBar(maxval=self.reads_found,
widgets=barformat_finalized)
self.pbar.currval = self.reads_processed
self.pbar.start()
else:
self.pbar.maxval = self.reads_found
self.pbar.update(self.reads_processed)
try:
await asyncio.sleep(0.3)
except CancelledError:
break
def __init__(self):
self.status_label = pbwidgets.FormatLabel(status_string(""))
self.pb = ProgressBar(1.0, widgets=[self.status_label,
pbwidgets.Percentage(), ' ', pbwidgets.Bar(),
pbwidgets.FormatLabel(" %(elapsed)s "),
pbwidgets.AdaptiveETA(),
])
self.last_status = None
self.pb.start()
def get_pbar(max_value):
pbar = progressbar.ProgressBar(widgets=[
widgets.Percentage(), ' (',
widgets.SimpleProgress(), ')', ' ',
widgets.Bar(), ' ',
widgets.Timer(), ' ',
widgets.AdaptiveETA(), ' ',
widgets.DynamicMessage('Accuracy')
],
max_value=max_value)
return pbar
def _iteration_parameters_values(value1, value2):
# Set widget and pbar
progress_widgets = [' Perc: ', widgets.Percentage(), ' ', \
widgets.Bar(marker='*', left='[', right=']'), ' ', \
widgets.ETA(), ' ', widgets.FileTransferSpeed()]
progress_bar = ProgressBar(widgets=progress_widgets,
maxval=value1 * value2)
progress_bar.start()
return 1, progress_bar
def DisplayProgressBar(self,
ProcessingResults,
ExpectedResultsSize,
CheckInterval=1,
type="minute"):
'''
Display a progress bar for multiprocessing. This function should be used after pool.close(No need to use pool.join anymore).
The call back function for pool.async should be set as CallbackForProgressBar.
:param multiprocessing.pool.AsyncResult ProcessingResults: Processing results returned by pool.async.
:param int ExpectedResultsSize: How many result you will reveive, i.e. the total length of progress bar.
:param float CheckInterval: How many seconds will the progress bar be updated. When it's too large, the main program may hang there.
:param String type: Three types: "minute", "hour", "second"; corresponds displaying iters/minute iters/hour and iters/second.
'''
self.ProcessingResults = ProcessingResults
ProgressBarWidgets = [
progressbar_widgets.Percentage(), ' ',
progressbar_widgets.Bar(), ' ',
progressbar_widgets.SimpleProgress(), ' ',
progressbar_widgets.Timer(), ' ',
progressbar_widgets.AdaptiveETA()
]
self.ProgressBar = progressbar.ProgressBar(ExpectedResultsSize,
ProgressBarWidgets)
self.StartTime = time.time()
PreviousNumberOfResults = 0
self.ProgressBar.start()
while self.ProcessingResults.ready() == False:
self.Update()
time.sleep(CheckInterval)
time.sleep(CheckInterval)
self.Update()
self.ProgressBar.finish()
self.EndTime = time.time()
print("Processing finished.")
#print "Processing results: ", self.TotalResults
print("Time Elapsed: %.2fs, or %.2fmins, or %.2fhours" %
((self.EndTime - self.StartTime),
(self.EndTime - self.StartTime) / 60,
(self.EndTime - self.StartTime) / 3600))
logger.info("Processing finished.")
logger.info("Processing results: " + str(self.TotalResults))
logger.info("Time Elapsed: %.2fs, or %.2fmins, or %.2fhours" %
((self.EndTime - self.StartTime),
(self.EndTime - self.StartTime) / 60,
(self.EndTime - self.StartTime) / 3600))
return
def get_progressbar_widget_list(nepoch: int) -> BarWidgetsReturn:
epoch_status_fmt_str: str = 'EPOCH: %(epoch_ix)d/%(nepoch)d'
epoch_status = progressbar.FormatCustomText(
epoch_status_fmt_str, dict(epoch_ix=0, nepoch=nepoch))
widgets_list: List[widgets.WidgetBase] = [
widgets.Percentage(),
' ',
widgets.SimpleProgress(format='(%s)' %
widgets.SimpleProgress.DEFAULT_FORMAT),
' ',
epoch_status,
' ',
widgets.Bar(),
' ',
widgets.Timer(),
]
return widgets_list, epoch_status
def __init__(self, prefix, max_value):
ProgressBar.__init__(self,
prefix=prefix,
max_value=max_value,
is_terminal=True,
term_width=200)
self.widgets = [
widgets.Percentage(**self.widget_kwargs),
' ',
widgets.SimpleProgress(format='(%s)' %
widgets.SimpleProgress.DEFAULT_FORMAT,
**self.widget_kwargs),
' ',
widgets.Bar(**self.widget_kwargs),
' ',
widgets.Timer(**self.widget_kwargs),
' ',
widgets.ETA(**self.widget_kwargs),
]
def start(self, time_max):
""" Start the simulation's progress bar
Args:
time_max (:obj:`float`): the simulation's end time
"""
if self.use:
self.bar = ProgressBar(widgets=[
widgets.Percentage(),
' ',
widgets.SimpleProgress(
format='%(value)d/%(max_value)d (time_max)'),
' ',
widgets.Bar(),
' ',
widgets.Timer(),
' ',
widgets.AdaptiveETA(),
],
max_value=time_max).start()
def download(url, filename):
"""Attempts to download url to filename unless the two files have the same size"""
r = requests.get(url, stream=True)
size = int(r.headers.get('Content-Length'))
bname = basename(filename)
if size and isfile(filename) and os.path.getsize(filename) == size:
print('File %s already exists, skipping download' % bname, file=sys.stderr)
return
currdown = 0.0
fmt = [
'Downloading %s: ' % bname, widgets.Bar(), ' ',
widgets.RotatingMarker(), ' ', widgets.Percentage(), ' ',
widgets.FileTransferSpeed(), ' ', widgets.ETA()
]
progress = ProgressBar(maxval=size or 100, widgets=fmt)
progress.start()
# https://stackoverflow.com/a/5137509
mkdir_p(dirname(realpath(filename)))
# https://stackoverflow.com/a/16696317
with open(filename, 'wb') as f:
for chunk in r.iter_content(chunk_size=65536):
if chunk:
f.write(chunk)
currdown += len(chunk)
if size:
progress.update(currdown)
else:
progress.update(random.randint(0, 100))
progress.finish()
from .Error import Error
from .llvm_wrapper import (encapsulate_symbolic, optimize_redundant_globals,
prepend_error_from_ktest)
from .threads import thread_phase_one, thread_fuzz_phase_one, thread_flipper_phase_one, thread_phase_two, thread_flipper_fuzzing_first_phase_one
from .cgroups import get_cgroups
from .Fuzzer import FuzzManager
from .Logger import Logger
from .analyse.linecoverage import linecoverage
# The widgets used by the process bar
WIDGETS = [
widgets.Percentage(),
' (',
widgets.SimpleProgress(),
')',
' ',
widgets.Bar("="),
' ',
widgets.Timer(),
' ',
widgets.ETA(),
]
class Macke:
"""
Main container for all steps of the MACKE analysis
