SLD/SRD für 64 Bit?

H

Hawkster

Level-1
Beiträge
90
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo allesamt,

habe derzeit das Problem das ich gern 64 Bit nach links bzw. Rechts schieben würde.
Problem ist nun, habe nen Mega-Baustein geschrieben, welcher das Bit für Bit in einer Schleife eingebettet macht... aber der richtig übel Zykluszeit frisst :(

Hat jemand ne gute Idee wie ich einen 64-Bit-Schiebe-Befehl mit wenig Zykluszeitbelastung realisieren kann!?

Mit freundlichen Grüßen,
Hawkster
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Mal ein Beispiel wie man es ohne Schleife machen kann.

Wenn mehr als 32 Bits geschoben werden sollen müsste man das noch etwas erweitern (in zwei Schritte aufteilen, einmal mit 32 bits und dann nochmal mit dem Rest).

Code: 
FUNCTION "SLDD" : VOID

VAR_INPUT
  IN_dwLOW : DWORD ;    
  IN_dwHIGH : DWORD ;    
  N : INT ;    //Anzahl
END_VAR
VAR_OUTPUT
  OUT_dwLOW : DWORD ;    
  OUT_dwHIGH : DWORD ;    
END_VAR
VAR_TEMP
  dwMask : DWORD ;    
  dwUebertrag : DWORD ;    
  dwTemp : DWORD ;    
END_VAR
BEGIN
NETWORK
TITLE =

// Bitmaske bilden 2^N
      L     #N; 
      L     DW#16#FFFFFFFF; 
      SLD   ; // Bitmaske um n Stellen nach links schieben
      T     #dwMask; 

// Low DWORD bearbeiten
      L     #N; 
      L     #IN_dwLOW; 
      RLD   ; 
      T     #dwTemp; 
// Reingeschobene Bits auf Null setzen
      L     #dwMask; 
      UD    ; 
      T     #OUT_dwLOW; 

// Übertragsbits aufräumen
      L     #dwMask; 
      INVD  ; 
      L     #dwTemp; 
      UD    ; 
      T     #dwTemp; 

// High DWORD bearbeiten
      L     #N; 
      L     #IN_dwHIGH; 
      SLD   ; 
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp; 
      OD    ; 
      T     #OUT_dwHIGH; 
END_FUNCTION
 
Also, Grund ist einfach..,

ich habe ein Array 1..64 und dazu 2 dw's, nun muss ich die high-Pegel in den bitmustern suchen, und anhand des jeweiligen bit's den entsprechenden Array-Index herauskopieren...
 
hier eine kleine einfache lösung, die ich mehrfach ausprobiert habe:

L 1
L DB1.DBD0 //HighDW schieben
SLD
T DB1.DBD0

U DB1.DBX 4.7 // ist das höchste Bit des LowDW=1
S DB1.DBX 3.0 // setze das niedrigste Bit des HighDW

L 1
L DB1.DBD4 //LowDW schieben
SLD
T DB1.DBD4
 
Vielen dank an Thomas, hab auf deiner Lösung aufgebaut und das ganze halt auf 64 Bit erweitert.

Hier meine Lösung

Netzwerk zum Rechts schieben:
Code: 
      NOP   0
//#############################################################
//### Aufbau der Konstilationen
//#############################################################        
      U(    
      L     #Rechts
      L     32
      >=I  
      )    
      SPB   Y_RS
      SPA   N_RS

//==> Es werden mehr als 32 Bit geschoben
Y_RS: NOP   0
      L     32
      T     #Schiebe_1

      L     #Rechts
      L     32
      -I    
      T     #Schiebe_2

      SPA   E_RS

//==> Es werden maximal 32 Bit geschoben
N_RS: NOP   0
      L     #Rechts
      T     #Schiebe_1

      L     0
      T     #Schiebe_2
      SPA   E_RS

E_RS: NOP   0

//#############################################################
//### Schiebe 0-32
//#############################################################
// Bitmaske bilden 2^N
      L     #Schiebe_1
      L     DW#16#FFFFFFFF
      SRD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_2_2
      RRD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_2_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_1_2
      SRD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_1_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

//#############################################################
//### Schiebe 33-64
//#############################################################
// Bitmaske bilden 2^N
      L     #Schiebe_2
      L     DW#16#FFFFFFFF
      SRD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_2_2
      RRD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_2_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_1_2
      SRD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_1_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2
Netzwerk zum Links schieben:
Code: 
      NOP   0
//#############################################################
//### Aufbau der Konstilationen
//#############################################################        
      U(    
      L     #Links
      L     32
      >=I  
      )    
      SPB   Y_LS
      SPA   N_LS

//==> Es werden mehr als 32 Bit geschoben
Y_LS: NOP   0
      L     32
      T     #Schiebe_1

      L     #Links
      L     32
      -I    
      T     #Schiebe_2

      SPA   E_LS

//==> Es werden maximal 32 Bit geschoben
N_LS: NOP   0
      L     #Links
      T     #Schiebe_1

      L     0
      T     #Schiebe_2
      SPA   E_LS

E_LS: NOP   0

//#############################################################
//### Schiebe 0-32
//#############################################################        
// Bitmaske bilden 2^N
      L     #Schiebe_1
      L     DW#16#FFFFFFFF
      SLD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_1_2
      RLD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_1_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_1
      L     #Bitmuster_2_2
      SLD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_2_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2

//#############################################################
//### Schiebe 33-64
//#############################################################        
// Bitmaske bilden 2^N
      L     #Schiebe_2
      L     DW#16#FFFFFFFF
      SLD                               // Bitmaske um n Stellen nach links schieben
      T     #dwMask

// Low DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_1_2
      RLD  
      T     #dwTemp
// Reingeschobene Bits auf Null setzen
      L     #dwMask
      UD    
      T     #t_Bitmuster_1_2

// Übertragsbits aufräumen
      L     #dwMask
      INVD  
      L     #dwTemp
      UD    
      T     #dwTemp

// High DWORD bearbeiten
      L     #Schiebe_2
      L     #Bitmuster_2_2
      SLD  
// Übertragsbits vom unteren DWORD setzen
      L     #dwTemp
      OD    
      T     #t_Bitmuster_2_2

      L     #t_Bitmuster_2_2
      T     #Bitmuster_2_2

      L     #t_Bitmuster_1_2
      T     #Bitmuster_1_2
 

Similar threads

H
Todes-Schleife...
2 3 4
Antworten
67
Aufrufe
16K
Zottel
Zottel
Zurück
Oben