def op_populate_with_range(ops_arg, tables, icount, random_range, pop_threads):
table_count = len(tables)
entries_per_table = (icount + random_range) / table_count
if entries_per_table == 0:
# This can happen if table_count is huge relative to
# icount/random_range. Not really worth handling.
raise Exception('table_count > (icount + random_range), seems absurd')
if (icount + random_range) % table_count != 0:
# This situation is not handled well by our simple algorithm,
# we won't get exactly icount entries added during the populate.
raise Exception('(icount + random_range) is not evenly divisible by ' +
'table_count')
if entries_per_table % pop_threads != 0:
# Another situation that is not handled exactly.
raise Exception('(icount + random_range) is not evenly divisible by ' +
'populate_threads')
fill_tables = icount / entries_per_table
fill_per_thread = entries_per_table / pop_threads
ops = None
for i in range(0, fill_tables):
op = Operation(ops_arg)
op._table = tables[i]
ops = op_append(ops, op * fill_per_thread)
partial_fill = icount % entries_per_table
if partial_fill > 0:
fill_per_thread = partial_fill / pop_threads
op = Operation(ops_arg)
op._table = tables[fill_tables]
ops = op_append(ops, op * fill_per_thread)
return ops
def _op_multi_table_as_list(ops_arg, tables, pareto_tables, multiplier):
result = []
if ops_arg._optype != Operation.OP_NONE:
if pareto_tables <= 0:
for table in tables:
for i in range(0, multiplier):
result.append(Operation(ops_arg._optype, table, ops_arg._key, ops_arg._value))
else:
# Use the multiplier unless the length of the list will be large.
# In any case, make sure there's at least a multiplier of 3, to
# give a chance to hit all/most of the tables.
ntables = len(tables)
count = ntables * multiplier
if count > 1000:
count = 1000
mincount = ntables * 3
if mincount > count:
count = mincount
for i in range(0, count):
tnum = _choose_pareto(ntables, pareto_tables)
# Modify the pareto value to make it more flat
# as tnum gets higher. Workgen knows how to handle
# a portion of a pareto range.
table = tables[tnum]
key = Key(ops_arg._key)
key._pareto.range_low = (1.0 * i)/count
key._pareto.range_high = (1.0 * (i + 1))/count
result.append(Operation(ops_arg._optype, table, key, ops_arg._value))
else:
for op in _op_get_group_list(ops_arg):
for o in _op_multi_table_as_list(op, tables, pareto_tables, \
multiplier):
result.append(Operation(o))
return result
def timed(seconds, op):
if op._group == None:
result = Operation()
result._group = OpList([op])
result._repeatgroup = 1
else:
result = op
result._timed = seconds
return result
def timed(seconds, op):
if op._group == None:
result = Operation()
result._group = OpList([op])
result._repeatgroup = 1
else:
result = op
result._timed = seconds
return result
def op_copy(src, table=None, key=None):
# Copy constructor does a deep copy, including subordinate
# operations and any attached transaction.
op = Operation(src)
if table != None or key != None:
_op_copy_mod(op, table, key)
return op
def _op_log_op(op, log_table):
keysize = op._key._size
if keysize == 0:
keysize = op._table.options.key_size
valuesize = op._value._size
if valuesize == 0:
valuesize = op._table.options.value_size
v = Value(keysize + valuesize)
return Operation(Operation.OP_INSERT, log_table, _logkey, v)
def _op_multi_table_as_list(ops_arg, tables):
result = []
if ops_arg._optype != Operation.OP_NONE:
for table in tables:
result.append(
Operation(ops_arg._optype, table, ops_arg._key,
ops_arg._value))
else:
for op in ops._group:
result.extend(_op_multi_table_as_list(op, tables))
return result
def op_populate_with_range(ops_arg, tables, icount, random_range, pop_threads):
table_count = len(tables)
entries_per_table = (icount + random_range) // table_count
if entries_per_table == 0:
# This can happen if table_count is huge relative to
# icount/random_range. Not really worth handling.
raise Exception('table_count > (icount + random_range), seems absurd')
if (icount + random_range) % table_count != 0:
# This situation is not handled well by our simple algorithm,
# we won't get exactly icount entries added during the populate.
raise Exception('(icount + random_range) is not evenly divisible by ' +
'table_count')
if entries_per_table % pop_threads != 0:
# Another situation that is not handled exactly.
raise Exception('(icount + random_range) is not evenly divisible by ' +
'populate_threads')
fill_tables = icount // entries_per_table
fill_per_thread = entries_per_table // pop_threads
ops = None
for i in range(0, fill_tables):
op = Operation(ops_arg)
op._table = tables[i]
ops = op_append(ops, op * fill_per_thread)
partial_fill = icount % entries_per_table
if partial_fill > 0:
fill_per_thread = partial_fill // pop_threads
op = Operation(ops_arg)
op._table = tables[fill_tables]
ops = op_append(ops, op * fill_per_thread)
return ops
def sleep(seconds):
return Operation(Operation.OP_SLEEP, str(seconds))