tfeneuil
/
python-elmo
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Python-ELMO is a Python library which offers an encapsulation of the binary tool ELMO, in order to manipulate it easily in Python and SageMath script.
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
1 Revīzija
1 Atzars
Koks: 926764d0fc
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '926764d0fc'
${ noResults }
python-elmo/engine.py

engine.py 8.8KB
Neapstrādāts Vainot Vēsture 

  1. import numpy as np

  2. import os

  3. 

  4. def hweight(n):

  5.     c = 0

  6.     while n>0:

  7.         c += (n & 1)

  8.         n >>= 1

  9.     return c

  10. 

  11. def hdistance(x,y):

  12.     return hweight(x^y)

  13. 

  14. def binary_writing(n, nb_bits=32, with_hamming=False):

  15.     n = np.array(n)

  16.     w, h = np.zeros((nb_bits, len(n))), np.zeros((len(n)))

  17. 

  18.     for ind in range(nb_bits):

  19.         w[ind] = (n & 1)

  20.         h += w[ind]

  21. 

  22.         n >>= 1

  23.         ind += 1

  24.     

  25.     return (w, h) if with_hamming else w

  26.     

  27. PREVIOUS = 0

  28. CURRENT = 1

  29. SUBSEQUENT = 2

  30. 

  31. class ELMOEngine:

  32.     def __init__(self):

  33.         self.load_coefficients()

  34.         self.reset_points()

  35.     

  36.     def _extract_data(self, nb):

  37.         coeffs = self.coefficients[self.pos:self.pos+nb]

  38.         self.pos += nb

  39.         return coeffs

  40. 

  41.     def load_coefficients(self):

  42.         filename = os.path.dirname(os.path.abspath(__file__))+'/elmo/coeffs.txt'

  43.         self.coefficients = None

  44.         with open(filename, 'r') as _file:

  45.             self.coefficients = np.array([list(map(float, line.split())) for line in _file.readlines()[:2153]])

  46.         

  47.         if self.coefficients is None:

  48.             raise IOError('Problem to read the coefficients.')

  49.         

  50.         self.pos = 0

  51.         

  52.         self.constant = np.squeeze(self._extract_data(1))

  53.         

  54.         self.PrvInstr = self._extract_data(4)

  55.         self.SubInstr = self._extract_data(4)

  56.         

  57.         self.Operand1 = self._extract_data(32)

  58.         self.Operand2 = self._extract_data(32)

  59.         self.BitFlip1 = self._extract_data(32)

  60.         self.BitFlip2 = self._extract_data(32)

  61.         

  62.         self.HWOp1PrvInstr = self._extract_data(4)

  63.         self.HWOp2PrvInstr = self._extract_data(4)

  64.         self.HDOp1PrvInstr = self._extract_data(4)

  65.         self.HDOp2PrvInstr = self._extract_data(4)

  66.         self.HWOp1SubInstr = self._extract_data(4)

  67.         self.HWOp2SubInstr = self._extract_data(4)

  68.         self.HDOp1SubInstr = self._extract_data(4)

  69.         self.HDOp2SubInstr = self._extract_data(4)

  70.         

  71.         self.Operand1_bitinteractions = self._extract_data(496)

  72.         self.Operand2_bitinteractions = self._extract_data(496)

  73.         self.BitFlip1_bitinteractions = self._extract_data(496)

  74.         self.BitFlip2_bitinteractions = self._extract_data(496)

  75.     

  76.     def reset_points(self):

  77.         self.points = []

  78.         self.power = None

  79.         

  80.     def add_point(self, triplet, previous_ops, current_ops):

  81.         self.points.append((triplet, previous_ops, current_ops))

  82.     

  83.     def _dot(self, a, b):

  84.         return np.sum(a * b, axis=0)

  85.         

  86.     def calculate_point(self, triplet, previous_ops, current_ops, debug=False):

  87.         nb_points = triplet.shape[1]

  88.         instructiontype = triplet[CURRENT]

  89.         instructiontype = instructiontype % 5 # Type 5 = Instruction was not profiled

  90.                 

  91.         # Previous

  92.         previous_instruction_typedec = triplet[PREVIOUS]

  93.         previous_instruction_type = np.zeros((5, nb_points))

  94.         for i in range(nb_points):

  95.             if previous_instruction_typedec[i] < 5:

  96.                 previous_instruction_type[previous_instruction_typedec[i],i] = 1

  97.         

  98.         # Current

  99.         (current_op1_binary, hw_op1) = binary_writing(current_ops[0], with_hamming=True)

  100.         (current_op2_binary, hw_op2) = binary_writing(current_ops[1], with_hamming=True)

  101. 

  102.         (current_op1_bitflip, hd_op1) = binary_writing(previous_ops[0] ^ current_ops[0], with_hamming=True)

  103.         (current_op2_bitflip, hd_op2) = binary_writing(previous_ops[1] ^ current_ops[1], with_hamming=True)

  104.         

  105.         current_instruction_typedec = instructiontype

  106.         current_instruction_type = np.zeros((5, nb_points))

  107.         for i in range(nb_points):

  108.             if triplet[CURRENT,i] < 5:

  109.                 current_instruction_type[current_instruction_typedec[i],i] = 1

  110.         

  111.         # Subsequent

  112.         subsequent_instruction_typedec = triplet[SUBSEQUENT]

  113.         subsequent_instruction_type = np.zeros((5, nb_points))

  114.         for i in range(nb_points):

  115.             if subsequent_instruction_typedec[i] < 5:

  116.                 subsequent_instruction_type[subsequent_instruction_typedec[i],i] = 1

  117. 

  118.         # Component variables

  119.         PrvInstr_data = self._dot( previous_instruction_type[1:], self.PrvInstr[:,instructiontype] )

  120.         SubInstr_data = self._dot( subsequent_instruction_type[1:], self.SubInstr[:,instructiontype] )

  121.         

  122.         Operand1_data = self._dot( current_op1_binary, self.Operand1[:,instructiontype] )

  123.         Operand2_data = self._dot( current_op2_binary, self.Operand2[:,instructiontype] )

  124.         BitFlip1_data = self._dot( current_op1_bitflip, self.BitFlip1[:,instructiontype] )

  125.         BitFlip2_data = self._dot( current_op2_bitflip, self.BitFlip2[:,instructiontype] )

  126.         

  127.         HWOp1PrvInstr_data = hw_op1 * self._dot(previous_instruction_type[1:], self.HWOp1PrvInstr[:,instructiontype])

  128.         HWOp2PrvInstr_data = hw_op2 * self._dot(previous_instruction_type[1:], self.HWOp2PrvInstr[:,instructiontype])

  129.         HDOp1PrvInstr_data = hd_op1 * self._dot(previous_instruction_type[1:], self.HDOp1PrvInstr[:,instructiontype])

  130.         HDOp2PrvInstr_data = hd_op2 * self._dot(previous_instruction_type[1:], self.HDOp2PrvInstr[:,instructiontype])

  131.         HWOp1SubInstr_data = hw_op1 * self._dot(subsequent_instruction_type[1:], self.HWOp1SubInstr[:,instructiontype])

  132.         HWOp2SubInstr_data = hw_op2 * self._dot(subsequent_instruction_type[1:], self.HWOp2SubInstr[:,instructiontype])

  133.         HDOp1SubInstr_data = hd_op1 * self._dot(subsequent_instruction_type[1:], self.HDOp1SubInstr[:,instructiontype])

  134.         HDOp2SubInstr_data = hd_op2 * self._dot(subsequent_instruction_type[1:], self.HDOp2SubInstr[:,instructiontype])

  135.         

  136.         Operand1_bitinteractions_data = np.zeros((nb_points))

  137.         Operand2_bitinteractions_data = np.zeros((nb_points))

  138.         BitFlip1_bitinteractions_data = np.zeros((nb_points))

  139.         BitFlip2_bitinteractions_data = np.zeros((nb_points))

  140.         

  141.         count = 0

  142.         for i in range(32):

  143.             for j in range(i+1,32):

  144.                 Operand1_bitinteractions_data += self.Operand1_bitinteractions[count,instructiontype] * current_op1_binary[i] * current_op1_binary[j]

  145.                 Operand2_bitinteractions_data += self.Operand2_bitinteractions[count,instructiontype] * current_op2_binary[i] * current_op2_binary[j]

  146. 

  147.                 BitFlip1_bitinteractions_data += self.BitFlip1_bitinteractions[count,instructiontype] * current_op1_bitflip[i] * current_op1_bitflip[j]

  148.                 BitFlip2_bitinteractions_data += self.BitFlip2_bitinteractions[count,instructiontype] * current_op2_bitflip[i] * current_op2_bitflip[j]

  149. 

  150.                 count += 1

  151.                 

  152.         power = self.constant[instructiontype] \

  153.                     + PrvInstr_data + SubInstr_data \

  154.                     + Operand1_data + Operand2_data \

  155.                     + BitFlip1_data + BitFlip2_data \

  156.                     + HWOp1PrvInstr_data + HWOp2PrvInstr_data \

  157.                     + HDOp1PrvInstr_data + HDOp2PrvInstr_data \

  158.                     + HWOp1SubInstr_data + HWOp2SubInstr_data \

  159.                     + HDOp1SubInstr_data + HDOp2SubInstr_data \

  160.                     + Operand1_bitinteractions_data + Operand2_bitinteractions_data \

  161.                     + BitFlip1_bitinteractions_data + BitFlip2_bitinteractions_data

  162.         

  163.         for i in range(nb_points):

  164.             if triplet[CURRENT,i] == 5:

  165.                 power[i] = self.constant[triplet[CURRENT,i]]

  166.                 

  167.         if debug:

  168.             print([self.constant[instructiontype], \

  169.                        PrvInstr_data, SubInstr_data, \

  170.                        Operand1_data, Operand2_data, \

  171.                        BitFlip1_data, BitFlip2_data, \

  172.                        HWOp1PrvInstr_data, HWOp2PrvInstr_data, \

  173.                        HDOp1PrvInstr_data, HDOp2PrvInstr_data, \

  174.                        HWOp1SubInstr_data, HWOp2SubInstr_data, \

  175.                        HDOp1SubInstr_data, HDOp2SubInstr_data, \

  176.                        Operand1_bitinteractions_data, Operand2_bitinteractions_data, \

  177.                        BitFlip1_bitinteractions_data, BitFlip2_bitinteractions_data])

  178.         return power

  179.     

  180.     def run(self):

  181.         nb_points = len(self.points)

  182.         triplet = np.array([p[0] for p in self.points]).T # shape = (3, nb_points)

  183.         previous_ops = np.array([p[1] for p in self.points]).T # shape = (2, nb_points)

  184.         current_ops = np.array([p[2] for p in self.points]).T # shape = (2, nb_points)

  185.         

  186.         self.power = self.calculate_point(triplet, previous_ops, current_ops)

  187.     

  188.     def oneshot_point(self, triplet, previous_ops, current_ops):

  189.         self.reset_points()

  190.         self.add_point(triplet, previous_ops, current_ops)

  191.         self.run()

  192.         return self.power