tfeneuil
/
python-elmo
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
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.
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
2 Révisions
1 Branche
Aborescence: 65fca61dce
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '65fca61dce'
${ noResults }
python-elmo/engine.py

engine.py 8.8KB
Brut Annotations Historique 

  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