def test12(self):
x = bits.bits().set_bytes((0xff, ), 7)
self.assertEqual(str(x), '(7) 1111111')
x = bits.bits().set_bytes((0x1, ), 7)
self.assertEqual(str(x), '(7) 0000001')
x = bits.bits().set_bytes((64, ), 7)
self.assertEqual(str(x), '(7) 1000000')
def reset_idcodes(self):
"""return a tuple of the idcodes for the JTAG chain"""
# a JTAG reset leaves DR as the 32 bit idcode for each device.
self.driver.trst()
tdi = bits.bits(self.ndevs * _idcode_length)
tdo = bits.bits()
self.driver.scan_dr(tdi, tdo)
return tdo.scan((_idcode_length, ) * self.ndevs)
def reset_idcodes(self):
"""return a tuple of the idcodes for the JTAG chain"""
# a JTAG reset leaves DR as the 32 bit idcode for each device.
self.driver.trst()
tdi = bits.bits(self.ndevs * _idcode_length)
tdo = bits.bits()
self.driver.scan_dr(tdi, tdo)
return tdo.scan((_idcode_length, ) * self.ndevs)
def cmd_sir(self, args):
"""command: SIR length TDI (tdi) SMASK (smask) [TDO (tdo) MASK (mask)]"""
vals = self.parse_tdi_tdo(args[1:])
tdi = bits.bits(vals['NBITS'], vals['TDI'])
if vals.has_key('TDO'):
tdo = bits.bits()
self.jtag.rw_ir(tdi, tdo)
self.validate_tdo(tdo, vals)
else:
self.jtag.wr_ir(tdi)
def test_file(directory, filename, window, symbol, search, _verbose=False):
data = bits()
with open(os.path.join(directory, filename), "rb") as file:
data.fromfile(file)
if _verbose:
print("[{} W:{} S:{} L:{}] Starting compression at {}".format(
filename, window, symbol, search, datetime.now()))
comp_start = datetime.now()
compressed = compress_lz77(data, symbol, window, search)
comp_end = datetime.now()
if _verbose:
print(
"[{} w{} s{} l{}] Data compressed, took {}, A compression ratio of {}"
.format(filename, window, symbol, search, comp_end - comp_start,
len(data) / len(compressed)))
dec_start = datetime.now()
decompressed = decode_lz77(compressed)
dec_end = datetime.now()
if _verbose:
print("[{} w{} s{} l{}] Data decompressed, took {}".format(
filename, window, symbol, search, dec_end - dec_start))
return filename, len(data), symbol, window, search, len(compressed), (
comp_end - comp_start).total_seconds(), (dec_end -
dec_start).total_seconds()
def cmd_compress(args):
assert os.path.isfile(args.input), "Input wasn't a file"
assert args.symbolSize > 0, "Positive symbol size required"
assert args.windowSize > 0, "Positive window size required"
output = args.output if args.output is not None else "{}.lz77".format(
args.input)
directory = os.path.dirname(output)
if not os.path.exists(directory):
print("Creating output directory...")
os.makedirs(directory)
data = bits()
with open(args.input, "rb") as file:
data.fromfile(file)
if args.lzss:
encoding = compress_lzss(data, args.symbolSize, args.windowSize,
args.maxSearch)
else:
encoding = compress_lz77(data, args.symbolSize, args.windowSize,
args.maxSearch)
with open(output, "wb+") as file:
encoding.tofile(file)
def chain_length(self, scan):
"""return the length of the JTAG chain"""
tdo = bits.bits()
# build a 000...001000...000 flush buffer for tdi
tdi = bits.bits(_flush_size)
tdi.append_ones(1)
tdi.append_zeroes(_flush_size)
scan(tdi, tdo)
# the first bits are junk
tdo.drop_lsb(_flush_size)
# work out how many bits tdo is behind tdi
s = tdo.bit_str()
s = s.lstrip('0')
if len(s.replace('0', '')) != 1:
raise Error('unexpected result from jtag chain - multiple 1\'s')
return len(s) - 1
def decode_lzss(data: bits):
symbol_bits, distance_bits, length_bits = (data.sub(i, 8).toint()
for i in range(0, 17, 8))
# print(f"symbol_bits={symbol_bits} distance_bits={distance_bits} length_bits={length_bits}")
bits_per = sum((symbol_bits, distance_bits, length_bits))
dec = bits()
dec_pos = 24
# print(data[24:])
while dec_pos < len(data):
flag, dec_pos = data.sub(dec_pos, 1).toint(), dec_pos + 1
if flag:
distance, dec_pos = data.sub(
dec_pos, distance_bits).toint(), dec_pos + distance_bits
length, dec_pos = data.sub(
dec_pos, length_bits).toint(), dec_pos + length_bits
dec.extend(
dec.sub(
len(dec) - ((distance) * symbol_bits),
length * symbol_bits))
nextSymbol, dec_pos = data.sub(dec_pos,
symbol_bits), dec_pos + symbol_bits
# print(f"Decoding dist={distance}, length={length}, nextSymbol={nextSymbol}")
dec.extend(nextSymbol)
# print(-(len(dec) % 8))
return dec
def compress_lzss(data: bits, symbol: int, window: int, max_length: int):
enc, enc_pos = bits().fromints(
8, (symbol, window.bit_length(), max_length.bit_length())), 0
data.extend(False for i in range((symbol - (len(data) % symbol))))
while enc_pos * symbol < len(data):
buffer_start, buffer_end, buffer_size = max(
0, enc_pos - window), enc_pos, min(enc_pos, window)
buffer = list(
data.sub(i * symbol, symbol)
for i in range(buffer_start, buffer_end))
distance, length, nextSymbol = 0, 0, data.sub(enc_pos * symbol, symbol)
matches = [
buffer_size - i for i, s in enumerate(buffer) if s == nextSymbol
]
# print(buffer, matches)
while len(matches) > 0 and length < max_length:
distance = matches[-1]
length += 1
nextSymbol = data.sub((enc_pos + length) * symbol, symbol)
matches = list(
filter(
lambda match: match - length > 0 and buffer[
-match + length] == nextSymbol, matches))
enc_pos += length + 1
# print(nextSymbol)
if distance + length > 0:
enc.append(True)
enc.fromint(window.bit_length(),
distance).fromint(max_length.bit_length(), length)
else:
enc.append(False)
enc.extend(nextSymbol)
return enc
def chain_length(self, scan):
"""return the length of the JTAG chain"""
tdo = bits.bits()
# build a 000...001000...000 flush buffer for tdi
tdi = bits.bits(_flush_size)
tdi.append_ones(1)
tdi.append_zeroes(_flush_size)
scan(tdi, tdo)
# the first bits are junk
tdo.drop_lsb(_flush_size)
# work out how many bits tdo is behind tdi
s = tdo.bit_str()
s = s.lstrip('0')
if len(s.replace('0', '')) != 1:
raise Error, 'unexpected result from jtag chain - multiple 1\'s'
return len(s) - 1
def held_karp_dicts(cities, count, verbose=True):
""" ([point],int,bool) -> float
Calculate the min-cost TSP tour for a list of cities.
Keyword arguments:
cities -- list of points in a 2-D plane
count -- number of cities
verbose -- optional parameter for extra diagnostics
"""
distances = distance_matrix(cities)
# Only non-trivial base case; if not in the table then assume +Inf
B = {1^(1<<count):0}
if verbose:
i = 0
start = time.clock()
for m in range(2, count+1):
# Get all the cities subsets of size m that include city 0
size_m_cities = bits.combinations_with_0(count, m)
A = {}
# subtract 1 b/c we ignore city 0
if verbose:
diagnostics_next_size(m, choose(count-1, m-1))
for S in size_m_cities:
if verbose:
if i % 100000 == 0:
diagnostics_set(i, time.clock()-start, sys.getsizeof(A),
sys.getsizeof(B))
start = time.clock()
i += 1
items = bits.bits(S)
for j in items[1:]: # ignore city 0
res = list()
for k in items:
if k == j:
continue
index_k = bits.generate_index(bits.delete_city(S, j),
count, k)
if index_k in B:
# calculate A[S-{j},k] + ckj
res.append(B[index_k] + distances[k][j])
# print res
A[bits.generate_index(S, count, j)] = min(res)
B = A
final_set = list(bits.combinations_with_0(count, count))[0]
return final_hop(count, final_set, B, distances)
def validate_tdo(self, tdo, vals):
"""validate returned tdo bits against expectations"""
if vals.has_key('TDO'):
n = vals['NBITS']
tdo_expected = bits.bits(n, vals['TDO'])
if vals.has_key('MASK'):
# new tdo mask value
self.mask = bits.bits(n, vals['MASK'])
else:
# validate old tdo mask value
if self.mask is None:
raise Error, 'line %d: no mask value set for tdo' % self.line
if len(self.mask) != n:
raise Error, 'line %d: bad mask length for tdo' % self.line
if (tdo & self.mask) != (tdo_expected & self.mask):
raise Error, 'line %d: tdo actual/expected mismatch' % self.line
def num_devices(self):
"""return the number of JTAG devices in the chain"""
# put every device into bypass mode (IR = all 1's)
tdi = bits.bits()
tdi.ones(_flush_size)
self.driver.scan_ir(tdi)
# now each DR is a single bit
# the DR chain length is the number of devices
return self.dr_length()
def num_devices(self):
"""return the number of JTAG devices in the chain"""
# put every device into bypass mode (IR = all 1's)
tdi = bits.bits()
tdi.ones(_flush_size)
self.driver.scan_ir(tdi)
# now each DR is a single bit
# the DR chain length is the number of devices
return self.dr_length()
def wr_dr(self, wr):
"""
write to DR for a device
wr: bitbuffer to be written to dr for this device
note - other devices are assumed to be in bypass mode
"""
tdi = bits.bits()
tdi.append_ones(self.ndevs_before)
tdi.append(wr)
tdi.append_ones(self.ndevs_after)
self.driver.scan_dr(tdi)
def wr_ir(self, wr):
"""
write to IR for a device
wr: the bitbuffer to be written to ir for this device
note - other devices will be placed in bypass mode (ir = all 1's)
"""
tdi = bits.bits()
tdi.append_ones(self.irlen_before)
tdi.append(wr)
tdi.append_ones(self.irlen_after)
self.driver.scan_ir(tdi)
def rd_dr(self, rd): """ read n-bits from a DR register note - other devices are assumed to be in bypass mode """ # add bits for the bypassed devices tdi = bits.bits(rd.n + self.ndevs_before + self.ndevs_after) self.driver.scan_dr(tdi, rd) # strip bits from the bypassed devices rd.drop_msb(self.ndevs_after) rd.drop_lsb(self.ndevs_before)
def wr_ir(self, wr):
"""
write to IR for a device
wr: the bitbuffer to be written to ir for this device
note - other devices will be placed in bypass mode (ir = all 1's)
"""
tdi = bits.bits()
tdi.append_ones(self.irlen_before)
tdi.append(wr)
tdi.append_ones(self.irlen_after)
self.driver.scan_ir(tdi)
def wr_dr(self, wr):
"""
write to DR for a device
wr: bitbuffer to be written to dr for this device
note - other devices are assumed to be in bypass mode
"""
tdi = bits.bits()
tdi.append_ones(self.ndevs_before)
tdi.append(wr)
tdi.append_ones(self.ndevs_after)
self.driver.scan_dr(tdi)
def rw_dr(self, wr, rd):
"""
read/write DR for a device
wr: bitbuffer to be written to dr for this device
rd: bitbuffer to be read from dr for this device
note - other devices are assumed to be in bypass mode
"""
tdi = bits.bits()
tdi.append_ones(self.ndevs_before)
tdi.append(wr)
tdi.append_ones(self.ndevs_after)
self.driver.scan_dr(tdi, rd)
# strip the dr bits from the bypassed devices
rd.drop_msb(self.ndevs_before)
rd.drop_lsb(self.ndevs_after)
def rw_dr(self, wr, rd):
"""
read/write DR for a device
wr: bitbuffer to be written to dr for this device
rd: bitbuffer to be read from dr for this device
note - other devices are assumed to be in bypass mode
"""
tdi = bits.bits()
tdi.append_ones(self.ndevs_before)
tdi.append(wr)
tdi.append_ones(self.ndevs_after)
self.driver.scan_dr(tdi, rd)
# strip the dr bits from the bypassed devices
rd.drop_msb(self.ndevs_before)
rd.drop_lsb(self.ndevs_after)
def cmd_decompress(args):
assert os.path.isfile(args.input), "Input wasn't a file"
output = args.output if args.output is not None else args.input.replace(
".lz77", "")
directory = os.path.dirname(output)
if not os.path.exists(directory):
print("Creating output directory...")
os.makedirs(directory)
encoding = bits()
with open(args.input, "rb") as file:
encoding.fromfile(file)
if args.lzss:
data = decode_lzss(encoding)
else:
data = decode_lz77(encoding)
with open(output, "wb+") as file:
data.tofile(file)
def rd_dr(self, n):
"""read n bits from the current data register"""
wr = bits.bits(n)
rd = bits.bits(n)
self.jtag.rw_dr(wr, rd)
return rd.scan((n, ))[0]
def wr_ir(self, val):
"""write instruction register"""
wr = bits.bits(self._IR_LEN, val)
self.jtag.wr_ir(wr)
def held_karp_scipy(cities, count, verbose=True):
""" ([point],int,bool) -> float
Calculate the min-cost TSP tour for a list of cities.
Keyword arguments:
cities -- list of points in a 2-D plane
count -- number of cities
verbose -- optional parameter for extra diagnostics
"""
distances = distance_matrix(cities)
# Only non-trivial base case; if not in the table then assume +Inf
# B = {1^(1<<count):0}
B = sparse.dok_matrix((2,1), dtype=np.float32) # or size 0?
B[1,0] = 0 # Of B[0,1] = 0?
if verbose:
i = 0
start = time.clock()
# pdb.set_trace()
for m in range(2, count+1):
# Get all the cities subsets of size m that include city 0
size_m_cities = bits.combinations_with_0(count, m)
A = sparse.dok_matrix((1<<count,count), dtype=np.float32)
# subtract 1 b/c we ignore city 0
if verbose:
diagnostics_next_size(m, choose(count-1, m-1))
for S in size_m_cities:
if verbose:
if i % 100000 == 0:
diagnostics_set(i, time.clock()-start, sys.getsizeof(A),
sys.getsizeof(B))
start = time.clock()
i += 1
items = bits.bits(S)
for j in items[1:]: # ignore city 0
res = list()
for k in items:
if k == j:
continue
S_old = bits.delete_city(S, j)
if B[S_old,k] != 0 or S_old == 1:
# calculate A[S-{j},k] + ckj
res.append(B[S_old,k] + distances[k][j])
A[S,j] = min(res)
B = A
final_set = list(bits.combinations_with_0(count, count))[0]
return final_hop2(count, final_set, B, distances)
def wr_dr(self, n, val): """write n bits to the current dr register""" wr = bits.bits(n, val) self.device.wr_dr(wr)
def wr_abort(self, val):
"""write abort register"""
self.wr_ir(_IR_ABORT)
self.device.wr_dr(bits.bits(_DR_ABORT_LEN, val))
def wr_ir(self, val): """write instruction register""" wr = bits.bits(_IR_LEN, val) self.device.wr_ir(wr)
def rw_dr(self, n, val = 0): """read/write n bits from the current dr register""" wr = bits.bits(n, val) rd = bits.bits(n) self.device.rw_dr(wr, rd) return rd.scan((n,))[0]
def wr_abort(self, val): """write abort register""" self.wr_ir(_IR_ABORT) self.device.wr_dr(bits.bits(_DR_ABORT_LEN, val))
def rw_dr(self, n, val=0):
"""read/write n bits from the current dr register"""
wr = bits.bits(n, val)
rd = bits.bits(n)
self.device.rw_dr(wr, rd)
return rd.scan((n, ))[0]
def wr_ir(self, val): """write instruction register""" self.device.wr_ir(bits.bits(_IR_LEN, val))
def wr_dr(self, n, val): """write current data register""" self.device.wr_dr(bits.bits(n, val))
def rd_dr(self, n): """read from current data register""" rd = bits.bits(n) self.device.rd_dr(rd) return rd.scan((n,))[0]
def wr_rd_dr(self, n, val): """write and read from current data register""" rd = bits.bits(n) self.device.wr_rd_dr(bits.bits(n, val), rd) return rd.scan((n,))[0]
def test13(self):
x = bits.from_tuple(str0)
y = bits.bits().set_bytes(x.get_bytes(), len(str0))
self.assertEqual(y.bit_str(), str0)
