def test_DataStreamProb_object(self):
a = data.DataStream.from_stoch(1000, 8, uniform=1, ro=0.4)
b = data.DataStream.from_stoch(1000,
8,
uniform=0,
ro=0.3,
mu=0,
log2_std=6)
c = data.DataStream.from_stoch(1000, 8) # random data
a_prob = data.DataStreamProb(a)
b_prob = data.DataStreamProb(b)
c_prob = data.DataStreamProb(c)
self.assertEqual(a_prob.B, a.B)
self.assertEqual(b_prob.B, 8)
self.assertTrue(
np.array_equal(a_prob.toggle_prob_vec, a.toggle_prob_vec))
self.assertFalse(
np.array_equal(c_prob.toggle_prob_vec, b.toggle_prob_vec))
self.assertTrue(
np.array_equal(c_prob.corr_switching_mat, c.corr_switching_mat))
self.assertFalse(
np.array_equal(a_prob.corr_switching_mat,
b_prob.corr_switching_mat))
self.assertTrue(np.array_equal(b_prob.bit_prob_mat, b.bit_prob_mat))
self.assertFalse(np.array_equal(a_prob.bit_prob_mat, c.bit_prob_mat))
# testing of the multiplexing?
# testing of the class method "from_prob"
Ts, Tc, pr = [1, 2, 3]
Ts_v, Tc_m, pr_m = np.ones(4), 2 * np.ones((4, 4)), 3 * np.ones((4, 4))
a_prob = data.DataStreamProb.from_probs(Ts, Tc, pr, 4)
b_prob = data.DataStreamProb.from_probs(Ts_v, Tc_m, pr_m, 4)
with self.assertRaises(IndexError):
data.DataStreamProb.from_probs(Tc_m, Tc_m, pr_m, 4)
data.DataStreamProb.from_probs(Ts, Tc_m, pr_m, 4)
def determine_error(muxProb, Nds, patCount, simRep, NB):
'''
runs the simulation for a multiplexing probability of
mux_prob, Nds multiplexed data streams with a pattern count
of 10e3. The simulation is repeated simRep times and
returned is the RMSE as well as the MAE
'''
for i in range(int(simRep)):
dsVec = []
dsProbVec = []
mse_vec = []
mse_vec_ref = []
max_error = 0
max_error_ref = 0
T_ref = np.zeros((NB, NB))
for j in range(Nds):
dsType = random.randint(1, 3)
if dsType == 1:
print('got a random')
ds = data.DataStream.from_stoch(patCount, NB)
elif dsType == 2:
print('got a gaussian')
std = (random.uniform(0.1, 1))*(NB - 1) # random std deviation
ro = random.random()
ds = data.DataStream.from_stoch(patCount, NB, 0, ro, 0, std)
else:
print('got a lognormal')
std = (random.uniform(0.1, 1))*(NB - 1) # random std deviation
ro = random.random()
ds = data.DataStream.from_stoch(patCount, NB, 0, ro, 0, std,
lognormal=True)
T_ref += ds.T
dsVec.append(ds)
dsProbVec.append(data.DataStreamProb(ds))
T_ref /= Nds
# REAL MULTIPLEXED DATASTREAM
realMuxedDs = dsVec[0].interleaving(dsVec[1:], muxProb)
# THEORETICAL (OUR MODEL)
muxMatrix, diagMatrix = np.zeros((2*Nds, 2*Nds)), np.zeros(2*Nds)
muxMatrix[0:Nds, 0:Nds] = muxProb/((Nds-1)*Nds)
diagMatrix[0:Nds] = (1-muxProb)/Nds
np.fill_diagonal(muxMatrix, diagMatrix)
if sum(sum(muxMatrix)) != 1:
print ("AUTO TEST DETECTED PROBLEM IN MUX MATRIX")
theoMuxedDs = data.DataStreamProb(dsProbVec, muxMatrix)
mse_vec.append(((theoMuxedDs.T - realMuxedDs.T) ** 2).mean())
max_error = max(max_error, np.abs(theoMuxedDs.T - realMuxedDs.T).max())
mse_vec_ref.append(((T_ref - realMuxedDs.T) ** 2).mean())
max_error_ref = max(max_error_ref, np.abs(T_ref - realMuxedDs.T).max())
rmse = np.sqrt(np.mean(mse_vec))
rmse_ref = np.sqrt(np.mean(mse_vec_ref))
return {"RMSE": rmse, "MAE": max_error, "RMSE REF": rmse_ref,
"MAE REF": max_error_ref, "DS": dsVec, "muxed": realMuxedDs}
def determine_speedup(muxProb, NB, Nds, patCount):
'''
runs the simulation for a multiplexing probability of
mux_prob, Nds multiplexed data streams with a pattern count
of pat_count.
'''
# Generate single data streams
dsVec = []
dsProbVec = []
for j in range(Nds):
dsType = random.randint(1, 3)
if dsType == 1:
print('got a random')
ds = data.DataStream.from_stoch(patCount, NB)
elif dsType == 2:
print('got a gaussian')
std = (random.uniform(0.1, 1)) * (NB - 1) # random std deviation
ro = random.random()
ds = data.DataStream.from_stoch(patCount, NB, 0, ro, 0, std)
else:
print('got a lognormal')
std = (random.uniform(0.1, 1)) * (NB - 1) # random std deviation
ro = random.random()
ds = data.DataStream.from_stoch(patCount,
NB,
0,
ro,
0,
std,
lognormal=True)
dsVec.append(ds)
dsProbVec.append(data.DataStreamProb(ds))
# Bit level timing
def bit_level_T():
realMuxedDs = dsVec[0].interleaving(dsVec[1:], muxProb)
T_bl = realMuxedDs.T
return T_bl
timeBitLevel = timeit.timeit(bit_level_T, number=10)
muxMatrix, diagMatrix = np.zeros((2 * Nds, 2 * Nds)), np.zeros(2 * Nds)
muxMatrix[0:Nds, 0:Nds] = muxProb / ((Nds - 1) * Nds)
diagMatrix[0:Nds] = (1 - muxProb) / Nds
np.fill_diagonal(muxMatrix, diagMatrix)
# High level timing
def high_level_T():
theoMuxedDs = data.DataStreamProb(dsProbVec, muxMatrix)
T_hl = theoMuxedDs.Tx
return T_hl
timeHighLevel = timeit.timeit(high_level_T, number=10)
return timeBitLevel / timeHighLevel
def power(self, data_inst=None, mux=None, f=1e9):
'''
returns power consumption of the interconnect for the specified
clock frequency "f". Also the transmitted data can be defined via
the variable "data_inst", by either:
#1: assigning instance of class "DataStream" or "DataStreamProbs"
#2: assigning array of samples (numpy or list/tuple)
#3: assigning mutliple instances of the the class "DataStream" or
"DataStreamProbs" via a list/tuple. In this scenarios, the
probabilities for the interleaving of the single DataStreams
has to be defined via variable "mux"
If "data_inst" is 'None', random data is assumed
'''
# # VAR1.__t_0 data unspecified (random data no hold assumed)
if data_inst is None:
C = self.C_2D + self.C_3D if self.is_3D is True else np.copy(
self.C_2D)
return met.mean_power2(C, self.Driver.V_dd, f, self.Driver.C_in) \
+ self._Nb*self.B*self.Driver.mean_power(f=f) # C load dep neg
# # VAR2: data specified
if isinstance(data_inst, (list, tuple, np.ndarray)): # samples
data_inst = data.DataStream(data_inst, self.B)
data_inst = data.DataStreamProb(data_inst, mux)
C = np.copy(self.C_2D)
if self.is_3D is True:
C = C + phs.TSV_cap_matrix_prob(self.TSV_length,
self.TSV_array_n,
self.TSV_array_m,
self.TSV_radius,
self.TSV_pitch,
data_inst.bit_prob_vec,
C_r=self.C_3D,
C_g=self._C_3D_g,
ground_ring=self.ground_ring)
return met.mean_power(data_inst.toggle_prob_vec,
data_inst.corr_switching_mat, C,
self.Driver.V_dd, f, self.Driver.C_in) \
+ self._Nb*sum(
self.Driver.mean_power(data_inst.toggle_prob_vec, f))
def high_level_T():
theoMuxedDs = data.DataStreamProb(dsProbVec, muxMatrix)
T_hl = theoMuxedDs.Tx
return T_hl
def test_DataStream_interleaving(self):
a = data.DataStream.from_stoch(10000,
8,
uniform=0,
ro=0.4,
mu=0,
log2_std=6)
b = data.DataStream.from_stoch(10000,
8,
uniform=0,
ro=-0.3,
mu=0,
log2_std=6)
c = data.DataStream.from_stoch(10000,
10,
uniform=0,
ro=-0.3,
mu=0,
log2_std=6)
d1 = a.samples
d2 = b.samples
tr_pr_d1 = [.5, .3, .2,
0] # trans probabilities from d1 to (d1, d2, h1, h2)
tr_pr_d2 = [.5, .4, 0,
.1] # trans probabilities from d2 to (d1, d2, h1, h2)
tr_pr_h1 = [.6, .3, .1,
0] # trans probabilities from h1 to (d1, d2, h1, h2)
tr_pr_h2 = [.1, .7, 0,
.2] # trans probabilities from h1 to (d1, d2, h1, h2)
state = 0 # start in state d1
tr_pr = tr_pr_d1
values = np.array([d1[0]])
d1 = np.delete(d1, 0)
mux = np.zeros((4, 4))
for i in range(10000 - 1):
x = random.random()
if x <= tr_pr[0]:
values = np.append(values, d1[0])
d1 = np.delete(d1, 0)
next_state = 0
next_tr_pr = tr_pr_d1
elif x <= (tr_pr[0] + tr_pr[1]):
values = np.append(values, d2[0])
d2 = np.delete(d2, 0)
next_state = 1
next_tr_pr = tr_pr_d2
elif x <= (tr_pr[0] + tr_pr[1] + tr_pr[2]):
values = np.append(values, values[len(values) - 1])
next_state = 2
next_tr_pr = tr_pr_h1
else:
values = np.append(values, values[len(values) - 1])
next_state = 3
next_tr_pr = tr_pr_h2
mux[state, next_state] += 1
tr_pr = next_tr_pr
state = next_state
mux = mux / (10000 - 1)
# self.assertEqual(sum(sum(mux)), 1)
ab_muxed = data.DataStream(values, B=8, is_signed=a.is_signed)
ab_muxed_theo = data.DataStreamProb([a, b], mux)
with self.assertRaises(ValueError):
data.DataStreamProb([a, c], mux)
with self.assertRaises(IndexError):
data.DataStreamProb([a, b], [0, 0])
# the following lines will sometimes cause faulty test results due to rounding!!
np.testing.assert_almost_equal(ab_muxed.toggle_prob_vec,
ab_muxed_theo.toggle_prob_vec,
decimal=1,
err_msg="\nMux Toggle Misprediction")
np.testing.assert_almost_equal(ab_muxed.corr_switching_mat,
ab_muxed_theo.corr_switching_mat,
decimal=1,
err_msg="\nMux Toggle Misprediction")
np.testing.assert_almost_equal(ab_muxed.bit_prob_vec,
ab_muxed_theo.bit_prob_vec,
decimal=1,
err_msg="\nMux Toggle Misprediction")