STM32F407 Cortex M4 şamataları

[z]

Bit banding, RAM ve Peripheral registerlerin bitlerine nokta atışı (bit bit) erişim demektir.

[ErsinErce]

Benim mantığım her bir manüplasyonuna başlangıçta interruptın disable, manüplasyon bitiminde de enable edilmesi gerektiği söylüyor.

Fakat dersenizki ben kodların tepesinde int disable edeceğim, en sonunda da açacağım anlayış gösteririm. Fakat delayler uzun süreli ise intteruptın da bizim kodlarımıza göre önceliği olduğunu varsayarsak her kod arasında enable disable işleminin yapılması gerekir.

dediğiniz doğru hocam ama bu kadar eint dint yapana kadar başka bir çözüm aramak daha mantıklı

volatile unsigned long intstate[2];
struct{
	volatile unsigned P0:1;
	volatile unsigned P1:1;
	volatile unsigned P2:1;
	volatile unsigned P3:1;
	volatile unsigned P4:1;
	volatile unsigned P5:1;
	volatile unsigned P6:1;
	volatile unsigned P7:1;
}Port __attribute__((at((unsigned long)&GPIOD->ODR)));
struct{
	volatile unsigned A0:1;
	volatile unsigned A1:1;
	volatile unsigned A2:1;
	volatile unsigned A3:1;
	volatile unsigned A4:1;
	volatile unsigned A5:1;
	volatile unsigned A6:1;
	volatile unsigned A7:1;
}A;
int main(void){
	int i;
	while(1){
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P6=A.A7;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=1;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=0;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P2=A.A0;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=1;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=0;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P4=A.A3;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=1;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
		intstate[0]=NVIC->ISER[0];
		intstate[1]=NVIC->ISER[1];
		NVIC->ICER[0]=0xFFFFFFFF;
		NVIC->ICER[1]=0xFFFFFFFF;
		
		Port.P0=0;
		
		NVIC->IABR[0]=intstate[0];
		NVIC->IABR[1]=intstate[0];
		for(i=0;i<0x10;i++);
	}
}

     4: volatile unsigned long intstate[2]; 
0x080001D0 4770      BX            lr
     5: void dint(void){ 
0x080001D2 487D      LDR           r0,[pc,#500]  ; @0x080003C8
     6:         intstate[0]=NVIC->ISER[0]; 
0x080001D4 6802      LDR           r2,[r0,#0x00]
0x080001D6 497D      LDR           r1,[pc,#500]  ; @0x080003CC
0x080001D8 600A      STR           r2,[r1,#0x00]
     7:         intstate[1]=NVIC->ISER[1]; 
0x080001DA 6842      LDR           r2,[r0,#0x04]
0x080001DC 604A      STR           r2,[r1,#0x04]
     8:         NVIC->ICER[0]=0xFFFFFFFF; 
0x080001DE F04F31FF  MOV           r1,#0xFFFFFFFF
0x080001E2 F8C01080  STR           r1,[r0,#0x80]
     9:         NVIC->ICER[1]=0xFFFFFFFF; 
0x080001E6 F8C01084  STR           r1,[r0,#0x84]
    10: } 
    11: void eint(void){ 
0x080001EA 4770      BX            lr
    12:         NVIC->IABR[0]=intstate[0]; 
0x080001EC 4877      LDR           r0,[pc,#476]  ; @0x080003CC
0x080001EE 6802      LDR           r2,[r0,#0x00]
0x080001F0 4977      LDR           r1,[pc,#476]  ; @0x080003D0
0x080001F2 600A      STR           r2,[r1,#0x00]
    13:         NVIC->IABR[1]=intstate[0]; 
0x080001F4 6800      LDR           r0,[r0,#0x00]
0x080001F6 6048      STR           r0,[r1,#0x04]
    14: } 
0x080001F8 4770      BX            lr
    43:                 Port.P6=A.A7; 
    44:                  
0x080001FA 4E74      LDR           r6,[pc,#464]  ; @0x080003CC
    38:                 intstate[0]=NVIC->ISER[0]; 
    39:                 intstate[1]=NVIC->ISER[1]; 
0x080001FC F04F20E0  MOV           r0,#0xE000E000
0x08000200 1F36      SUBS          r6,r6,#4
0x08000202 1D31      ADDS          r1,r6,#4
0x08000204 4B73      LDR           r3,[pc,#460]  ; @0x080003D4
    40:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x08000206 1742      ASRS          r2,r0,#29
0x08000208 F8D04100  LDR           r4,[r0,#0x100]
0x0800020C 600C      STR           r4,[r1,#0x00]
    39:                 intstate[1]=NVIC->ISER[1]; 
    40:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x0800020E F8D04104  LDR           r4,[r0,#0x104]
0x08000212 604C      STR           r4,[r1,#0x04]
0x08000214 F8C02180  STR           r2,[r0,#0x180]
    41:                 NVIC->ICER[1]=0xFFFFFFFF; 
    42:                  
0x08000218 F8C02184  STR           r2,[r0,#0x184]
    43:                 Port.P6=A.A7; 
    44:                  
0x0800021C 6834      LDR           r4,[r6,#0x00]
0x0800021E F3C415C0  UBFX          r5,r4,#7,#1
0x08000222 681C      LDR           r4,[r3,#0x00]
0x08000224 F3651486  BFI           r4,r5,#6,#1
0x08000228 601C      STR           r4,[r3,#0x00]
    45:                 NVIC->IABR[0]=intstate[0]; 
0x0800022A 680C      LDR           r4,[r1,#0x00]
0x0800022C F8C04300  STR           r4,[r0,#0x300]
    46:                 NVIC->IABR[1]=intstate[0]; 
0x08000230 680C      LDR           r4,[r1,#0x00]
0x08000232 F8C04304  STR           r4,[r0,#0x304]
    47:                 for(i=0;i<0x10;i++); 
0x08000236 2400      MOVS          r4,#0x00
0x08000238 1C64      ADDS          r4,r4,#1
0x0800023A 2C10      CMP           r4,#0x10
0x0800023C DBFC      BLT           0x08000238
    48:                 intstate[0]=NVIC->ISER[0]; 
0x0800023E F8D04100  LDR           r4,[r0,#0x100]
0x08000242 600C      STR           r4,[r1,#0x00]
    49:                 intstate[1]=NVIC->ISER[1]; 
0x08000244 F8D04104  LDR           r4,[r0,#0x104]
0x08000248 604C      STR           r4,[r1,#0x04]
    50:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x0800024A F8C02180  STR           r2,[r0,#0x180]
    51:                 NVIC->ICER[1]=0xFFFFFFFF; 
    52:                  
0x0800024E F8C02184  STR           r2,[r0,#0x184]
    53:                 Port.P0=1; 
    54:                  
0x08000252 681C      LDR           r4,[r3,#0x00]
0x08000254 F0440401  ORR           r4,r4,#0x01
0x08000258 601C      STR           r4,[r3,#0x00]
    55:                 NVIC->IABR[0]=intstate[0]; 
0x0800025A 680C      LDR           r4,[r1,#0x00]
0x0800025C F8C04300  STR           r4,[r0,#0x300]
    56:                 NVIC->IABR[1]=intstate[0]; 
0x08000260 680C      LDR           r4,[r1,#0x00]
0x08000262 F8C04304  STR           r4,[r0,#0x304]
    57:                 for(i=0;i<0x10;i++); 
0x08000266 2400      MOVS          r4,#0x00
0x08000268 1C64      ADDS          r4,r4,#1
0x0800026A 2C10      CMP           r4,#0x10
0x0800026C DBFC      BLT           0x08000268
    58:                 intstate[0]=NVIC->ISER[0]; 
0x0800026E F8D04100  LDR           r4,[r0,#0x100]
0x08000272 600C      STR           r4,[r1,#0x00]
    59:                 intstate[1]=NVIC->ISER[1]; 
0x08000274 F8D04104  LDR           r4,[r0,#0x104]
0x08000278 604C      STR           r4,[r1,#0x04]
    60:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x0800027A F8C02180  STR           r2,[r0,#0x180]
    61:                 NVIC->ICER[1]=0xFFFFFFFF; 
    62:                  
0x0800027E F8C02184  STR           r2,[r0,#0x184]
    63:                 Port.P0=0; 
    64:                  
0x08000282 681C      LDR           r4,[r3,#0x00]
0x08000284 F0240401  BIC           r4,r4,#0x01
0x08000288 601C      STR           r4,[r3,#0x00]
    65:                 NVIC->IABR[0]=intstate[0]; 
0x0800028A 680C      LDR           r4,[r1,#0x00]
0x0800028C F8C04300  STR           r4,[r0,#0x300]
    66:                 NVIC->IABR[1]=intstate[0]; 
0x08000290 680C      LDR           r4,[r1,#0x00]
0x08000292 F8C04304  STR           r4,[r0,#0x304]
    67:                 for(i=0;i<0x10;i++); 
0x08000296 2400      MOVS          r4,#0x00
0x08000298 1C64      ADDS          r4,r4,#1
0x0800029A 2C10      CMP           r4,#0x10
0x0800029C DBFC      BLT           0x08000298
    68:                 intstate[0]=NVIC->ISER[0]; 
0x0800029E F8D04100  LDR           r4,[r0,#0x100]
0x080002A2 600C      STR           r4,[r1,#0x00]
    69:                 intstate[1]=NVIC->ISER[1]; 
0x080002A4 F8D04104  LDR           r4,[r0,#0x104]
0x080002A8 604C      STR           r4,[r1,#0x04]
    70:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x080002AA F8C02180  STR           r2,[r0,#0x180]
    71:                 NVIC->ICER[1]=0xFFFFFFFF; 
    72:                  
0x080002AE F8C02184  STR           r2,[r0,#0x184]
    73:                 Port.P2=A.A0; 
    74:                  
0x080002B2 6834      LDR           r4,[r6,#0x00]
0x080002B4 681D      LDR           r5,[r3,#0x00]
0x080002B6 F3640582  BFI           r5,r4,#2,#1
0x080002BA 601D      STR           r5,[r3,#0x00]
    75:                 NVIC->IABR[0]=intstate[0]; 
0x080002BC 680C      LDR           r4,[r1,#0x00]
0x080002BE F8C04300  STR           r4,[r0,#0x300]
    76:                 NVIC->IABR[1]=intstate[0]; 
0x080002C2 680C      LDR           r4,[r1,#0x00]
0x080002C4 F8C04304  STR           r4,[r0,#0x304]
    77:                 for(i=0;i<0x10;i++); 
0x080002C8 2400      MOVS          r4,#0x00
0x080002CA 1C64      ADDS          r4,r4,#1
0x080002CC 2C10      CMP           r4,#0x10
0x080002CE DBFC      BLT           0x080002CA
    78:                 intstate[0]=NVIC->ISER[0]; 
0x080002D0 F8D04100  LDR           r4,[r0,#0x100]
0x080002D4 600C      STR           r4,[r1,#0x00]
    79:                 intstate[1]=NVIC->ISER[1]; 
0x080002D6 F8D04104  LDR           r4,[r0,#0x104]
0x080002DA 604C      STR           r4,[r1,#0x04]
    80:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x080002DC F8C02180  STR           r2,[r0,#0x180]
    81:                 NVIC->ICER[1]=0xFFFFFFFF; 
    82:                  
0x080002E0 F8C02184  STR           r2,[r0,#0x184]
    83:                 Port.P0=1; 
    84:                  
0x080002E4 681C      LDR           r4,[r3,#0x00]
0x080002E6 F0440401  ORR           r4,r4,#0x01
0x080002EA 601C      STR           r4,[r3,#0x00]
    85:                 NVIC->IABR[0]=intstate[0]; 
0x080002EC 680C      LDR           r4,[r1,#0x00]
0x080002EE F8C04300  STR           r4,[r0,#0x300]
    86:                 NVIC->IABR[1]=intstate[0]; 
0x080002F2 680C      LDR           r4,[r1,#0x00]
0x080002F4 F8C04304  STR           r4,[r0,#0x304]
    87:                 for(i=0;i<0x10;i++); 
0x080002F8 2400      MOVS          r4,#0x00
0x080002FA 1C64      ADDS          r4,r4,#1
0x080002FC 2C10      CMP           r4,#0x10
0x080002FE DBFC      BLT           0x080002FA
    88:                 intstate[0]=NVIC->ISER[0]; 
0x08000300 F8D04100  LDR           r4,[r0,#0x100]
0x08000304 600C      STR           r4,[r1,#0x00]
    89:                 intstate[1]=NVIC->ISER[1]; 
0x08000306 F8D04104  LDR           r4,[r0,#0x104]
0x0800030A 604C      STR           r4,[r1,#0x04]
    90:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x0800030C F8C02180  STR           r2,[r0,#0x180]
    91:                 NVIC->ICER[1]=0xFFFFFFFF; 
    92:                  
0x08000310 F8C02184  STR           r2,[r0,#0x184]
    93:                 Port.P0=0; 
    94:                  
0x08000314 681C      LDR           r4,[r3,#0x00]
0x08000316 F0240401  BIC           r4,r4,#0x01
0x0800031A 601C      STR           r4,[r3,#0x00]
    95:                 NVIC->IABR[0]=intstate[0]; 
0x0800031C 680C      LDR           r4,[r1,#0x00]
0x0800031E F8C04300  STR           r4,[r0,#0x300]
    96:                 NVIC->IABR[1]=intstate[0]; 
0x08000322 680C      LDR           r4,[r1,#0x00]
0x08000324 F8C04304  STR           r4,[r0,#0x304]
    97:                 for(i=0;i<0x10;i++); 
0x08000328 2400      MOVS          r4,#0x00
0x0800032A 1C64      ADDS          r4,r4,#1
0x0800032C 2C10      CMP           r4,#0x10
0x0800032E DBFC      BLT           0x0800032A
    98:                 intstate[0]=NVIC->ISER[0]; 
0x08000330 F8D04100  LDR           r4,[r0,#0x100]
0x08000334 600C      STR           r4,[r1,#0x00]
    99:                 intstate[1]=NVIC->ISER[1]; 
0x08000336 F8D04104  LDR           r4,[r0,#0x104]
0x0800033A 604C      STR           r4,[r1,#0x04]
   100:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x0800033C F8C02180  STR           r2,[r0,#0x180]
   101:                 NVIC->ICER[1]=0xFFFFFFFF; 
   102:                  
0x08000340 F8C02184  STR           r2,[r0,#0x184]
   103:                 Port.P4=A.A3; 
   104:                  
0x08000344 6834      LDR           r4,[r6,#0x00]
0x08000346 F3C405C0  UBFX          r5,r4,#3,#1
0x0800034A 681C      LDR           r4,[r3,#0x00]
0x0800034C F3651404  BFI           r4,r5,#4,#1
0x08000350 601C      STR           r4,[r3,#0x00]
   105:                 NVIC->IABR[0]=intstate[0]; 
0x08000352 680C      LDR           r4,[r1,#0x00]
0x08000354 F8C04300  STR           r4,[r0,#0x300]
   106:                 NVIC->IABR[1]=intstate[0]; 
0x08000358 680C      LDR           r4,[r1,#0x00]
0x0800035A F8C04304  STR           r4,[r0,#0x304]
   107:                 for(i=0;i<0x10;i++); 
0x0800035E 2400      MOVS          r4,#0x00
0x08000360 1C64      ADDS          r4,r4,#1
0x08000362 2C10      CMP           r4,#0x10
0x08000364 DBFC      BLT           0x08000360
   108:                 intstate[0]=NVIC->ISER[0]; 
0x08000366 F8D04100  LDR           r4,[r0,#0x100]
0x0800036A 600C      STR           r4,[r1,#0x00]
   109:                 intstate[1]=NVIC->ISER[1]; 
0x0800036C F8D04104  LDR           r4,[r0,#0x104]
0x08000370 604C      STR           r4,[r1,#0x04]
   110:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x08000372 F8C02180  STR           r2,[r0,#0x180]
   111:                 NVIC->ICER[1]=0xFFFFFFFF; 
   112:                  
0x08000376 F8C02184  STR           r2,[r0,#0x184]
   113:                 Port.P0=1; 
   114:                  
0x0800037A 681C      LDR           r4,[r3,#0x00]
0x0800037C F0440401  ORR           r4,r4,#0x01
0x08000380 601C      STR           r4,[r3,#0x00]
   115:                 NVIC->IABR[0]=intstate[0]; 
0x08000382 680C      LDR           r4,[r1,#0x00]
0x08000384 F8C04300  STR           r4,[r0,#0x300]
   116:                 NVIC->IABR[1]=intstate[0]; 
0x08000388 680C      LDR           r4,[r1,#0x00]
0x0800038A F8C04304  STR           r4,[r0,#0x304]
   117:                 for(i=0;i<0x10;i++); 
0x0800038E 2400      MOVS          r4,#0x00
0x08000390 1C64      ADDS          r4,r4,#1
0x08000392 2C10      CMP           r4,#0x10
0x08000394 DBFC      BLT           0x08000390
   118:                 intstate[0]=NVIC->ISER[0]; 
0x08000396 F8D04100  LDR           r4,[r0,#0x100]
0x0800039A 600C      STR           r4,[r1,#0x00]
   119:                 intstate[1]=NVIC->ISER[1]; 
0x0800039C F8D04104  LDR           r4,[r0,#0x104]
0x080003A0 604C      STR           r4,[r1,#0x04]
   120:                 NVIC->ICER[0]=0xFFFFFFFF; 
0x080003A2 F8C02180  STR           r2,[r0,#0x180]
   121:                 NVIC->ICER[1]=0xFFFFFFFF; 
   122:                  
0x080003A6 F8C02184  STR           r2,[r0,#0x184]
   123:                 Port.P0=0; 
   124:                  
0x080003AA 681C      LDR           r4,[r3,#0x00]
0x080003AC F0240401  BIC           r4,r4,#0x01
0x080003B0 601C      STR           r4,[r3,#0x00]
   125:                 NVIC->IABR[0]=intstate[0]; 
0x080003B2 680C      LDR           r4,[r1,#0x00]
0x080003B4 F8C04300  STR           r4,[r0,#0x300]
   126:                 NVIC->IABR[1]=intstate[0]; 
0x080003B8 680C      LDR           r4,[r1,#0x00]
0x080003BA F8C04304  STR           r4,[r0,#0x304]
   127:                 for(i=0;i<0x10;i++); 
0x080003BE 2400      MOVS          r4,#0x00
0x080003C0 1C64      ADDS          r4,r4,#1
0x080003C2 2C10      CMP           r4,#0x10
0x080003C4 DBFC      BLT           0x080003C0
0x080003C6 E71F      B             0x08000208

[Andromeda]

yani,  0' ı  1 yapmak veya tersi....ya da okumak...

[CLR]

Anladım hocam teşekkürler,
IAR'da MISRA C denetleyicisi vardı hatırladığım kadarıyla, bir yandan iyi gibi aslında bug oluşmasının önüne geçilmek isteniyor.
Kodlarken ne tarz sorunlar çıkartığına dair bir fikir oluşturması için aklınızda kalan ufak bir kaç örnek  varsa bilgilendirebilir misiniz hocam?

Şuan örnekler tam aklımda değil ama inline kullanıma izin vermiyordu ve enumeration kullanımlarında keille uyuşmayan durumlar çıkmıştı. Keil rahatlıkla derlerken iar'da hata veriyordu. Sonra derleyiciye göre tanımlamalarla sorunu çözdüm.

@bunalmış
Hadi herkes kendi yoluna, bundan sonra benim nick'imi kapsayan yazılar yazma.

[mcan]

C ile ,(derleyici olarak fark etmez) , Sram deki herhangi bir baytın ,örnek olarak atıyorum 1. bayt olsun 0x1,  1. bitini maskeleme ile set eden  kod bu mudur?

char a; // a'nın adresinin 0x1 olduğunu farz edelim
a|=1;

Kod buysa ,derleyicinin bu c kodu için üretebileceği en optimize asm kodu nedir? En optimize c kodu bu değilse nedir  ve en optimize asm karşılığı nedir?

[z]

u

@bunalmış
Hadi herkes kendi yoluna, bundan sonra benim nick'imi kapsayan yazılar yazma.

Müsade et de buna ben karar vereyim. Hatalı sorduğumu belirttiğim ve ve ardından soruyu düzeltiğim son soruma  enginnnnnn C bilginle bir el atarmısın?

[mcan]

Çok kısa olarak Bit Banding nedir..?

Kolaylık,bazı işlemler-durumlar için alternatif ,güvenilir ve hızlı bir yol.

Düz mantık ;
Adamlar hata yaptı m3 e koydu aynı adamlar kimsenin kullanmadığını bile bile(2-3 antika adam kullanıyor diye   ) gene hata yapıp m4 de de koymuşlar,hemde donanımsal bişeyi...

Yorumum; demek ki genel olarak  interrup tu iptal etmeden bir biti özellikle ortak kullanılan sram alanı üzerindeki bir biti set yada  reset etmek elzem olabiliyormuş ki adamlar bunu hw ye gömmüş...

Ayrıca dökümandan bulduğum bir örnekde bitband ile 80 ns de yaptığı işi diğer yöntemle 180 ns de yazmış ancak en optimize kod olduğundan konuya hakim olmadığımdan bişey diyemiyorum.

Bu arada sanırım güzel birşey buldum en azından keil için bit bandı daha konforlu kullanmaya yaradığını düşünüyorum.
@Eemkutay'ın yazdığı structure yapısına benzer biçimde,aynı konfor yakalanamayacağını düşünüyorum, bitbanding i kullanmaya yarıyor sanırım.

typedef struct {
  int i : 1;
  int j : 2;
  int k : 3;
} BB __attribute__((bitband));

BB bb __attribute__((at(0x20000004));

void foo(void)
{
  bb.i = 1;
}

http://www.keil.com/support/man/docs/armccref/armccref_babcbgfc.htm

Bunun örneğini yapıp kullanmaya çalışıcam...

[z]

C ile ,(derleyici olarak fark etmez) , Sram deki herhangi bir baytın ,örnek olarak atıyorum 1. bayt olsun 0x1,  1. bitini maskeleme ile set eden  kod bu mudur?

char a; // a'nın adresinin 0x1 olduğunu farz edelim
a|=1;

Kod buysa ,derleyicinin bu c kodu için üretebileceği en optimize asm kodu nedir? En optimize c kodu bu değilse nedir  ve en optimize asm karşılığı nedir?

ARM işlemcilerde optimizasyon tek bir komut için yapılmaz. Bir önceki satırda ne yaptık, şimdi ne yapacağım bir sonraki satırda hangi komutu işleteceğim sorularına göre yapılır.

a|=1; C komutu normalde 4 ASM komutu ister. Fakat peş peşe gelen C yada asm kodların durumuna göre bu bazen tek asm komutla dahi yazılabilir.

[mcan]

ARM işlemcilerde optimizasyon tek bir komut için yapılmaz. Bir önceki satırda ne yaptık, şimdi ne yapacağım bir sonraki satırda hangi komutu işleteceğim sorularına göre yapılır.Peş peşe gelen C yada asm kodların durumuna göre bu bazen tek asm komutla dahi yazılabilir.

wayyy ,neden? Bu işin pipeline ile alakası var mı? Belki alakası bile olmayabilir ama okuduğum şeyleri bağlantılamaya oturtmaya çalışıyorum. 

[mcan]

Kodu denedim çalışıyor , kullanmak isteyenler için örnek olarak buraya koyuyorum.
Bitbanding hemende yarı structure konforu ile, yarı diyorum çünki 1 den fazla bite erişmek nasıl bişey olur yada 1 bitten daha büyük değişken tanımlarsak nasıl bir kayma olur bilemiyorum...

#include "STM32F10x.h"


#define BIT_LEVEL_SRAM(a,b) ((SRAM_BB_BASE + (a-SRAM_BASE)*32 + (b*4)))
#define BIT_LEVEL_PERI(a,b) ((PERIPH_BB_BASE + (a-PERIPH_BASE)*32 + (b*4)))
#define	RCC_APB2ENR	(RCC_BASE+0x018)

#define GPIO_C_ENABLE *((volatile unsigned int *)(BIT_LEVEL_PERI(RCC_APB2ENR,4)))

void delay(unsigned int);
static int ih;
int zg,ipb,ii;

typedef struct {
  int Pin0 : 1;
  int Pin1 : 1;
  int Pin2 : 1;
  int Pin3 : 1;
  int Pin4 : 1;
  int Pin5 : 1;
  int Pin6 : 1;
  int Pin7 : 1;
  int Pin8 : 1;
  int Pin9 : 1;
} BB __attribute__((bitband));

BB PortC __attribute__((at(GPIOC_BASE+0x0C)));



void TIM7_IRQHandler(void)
{	
	ih =!ih ;

	while(TIM7->SR)
	{
		TIM7->SR  = 0x0;
	}
	
}

void SystemInit (void)
{
	delay(0x880000);
	GPIO_C_ENABLE = 1 ;
 	//RCC->APB2ENR |= 0x00000016;    // GPIOD donanımının clock sinyalini uygulayalım
    GPIOC->CRL = 0x37333333;     // GPIOD nin 15, 14, 13, 12 pinleri cikis tanimlandi (Ledler bu pinlerde)
	GPIOC->CRH = 0x33333333;

	RCC->CR |= 0x0010000;	   			// HSE ON
	RCC->CFGR = 0x001D0000;	   			// PLL ayarla
	RCC->CR  |= 0x001000000;	   		// PLL aç
	FLASH->ACR =  0x32;					// Flash gecikme ayarı
	RCC->CFGR = 0x001D0702;	   			// SİNYAL KAYNAĞI PLL	 APB1 HCLK/16

	RCC->APB1ENR |= 0x00000020;		    //Timer7 ye clock verelim
	TIM7->DIER = 0x1;
	TIM7->PSC = 0x1FF;			  		//182=B6  182*5= H393
	TIM7->ARR = 0xFFFF;
	TIM7->CR1  = 0x85;
	NVIC->ISER[1] = 0X00800000;        // NVIC de Timer 7 interrupta izin verelim

} 
																										   
void delay(unsigned int i)
{   unsigned int z;
    for(z=0;z<i;z++);
	 
}
 
int main()
{
    while(1)
   {
     if(ih)
	 	PortC.Pin5 = 1;		//GPIOC->ODR= 0x20;     // Ledler yansin
	 else
		PortC.Pin9 = 1;		//GPIOC->ODR= 0x200;     // Ledler yansin
	 delay(0x40000);
     GPIOC->ODR= 0x00000000;     // Ledler sonsun
	 delay(0x40000);
   } 
}

Komutumuz "PortC.Pin5 = 1;" buna indirgendi...

@Eemkutay sizin derleyici hangisi? structure için  isimden sonra nokta koyduğumda bana structure içerik seçeneklerini göstermiyor.

[z]

Bunalmış,

Kaçmak mı? Ben senin gibi değilim, ben haksız olduğuma inansaydım haklısın diyebilme erdemine sahibim. Ama sen bundan yoksunsun. Seni şahsen tanımıyorum ama forumda iyi tanıyorum. Hiçbirşeyi kabullenmeyen, öğrenmeye kapalı bir yapın var. Daha önceleri seninle asm ve c tartışmamız olmuştu. C'yi kötüleyip duruyordun, o zamanlar şimdiki gibi ns saniye hesabı yapıyordun. Ne oldu? Aradan zaman geçti daha yeni benim dediğime geldin. Şimdide aynısı olacak. Yakında C'de benim yazdığım gibi yazmayı öğreneceksin. Herzaman senin 3-5 adım önünde olacağım. Bu meslekte ve bu forumda tek çalışkan ve başarılı insan kendin sanıyorsun galiba.   

Başlangıçta bitbanding için sen 1 cycle'da çalışıyor dedin, ben 3 dedim. Sonra baktın yanlışsın lafı çevirdin, "en iyi ihtimalle 1 cycle" "en kötü ihtimalle 3 cycle" demeye başladın. Maksat "evet haklısın diyememek". Sonra bazı arkadaşlar netten kaynak falan çıkardılar, bu defa maskelemeden daha verimli olur demeye başladın. Hala da konuşabiliyorsun ve bana kaçma gibi bir laf söylüyorsun.

Seninle bu konu hakkında konuşmam için önce yukarıda bana sorduğun soruyu bitbanding ile yaz ve asm sonucunu buraya koy ve benim yukarıda yazdığım programla karşılaştıralım. Hem C formatını hemde asm formatını. Bana sözlü olarak bişeyler söylemen anlamsız, asm sonuçlarına bakarım. Asm çıktıda ezici üstünlük sağla, sonra konuşma hakkın olsun.

Bitbanding'in, hangi durumda 1 cycle, hangi durumda N cycle isleyecegini bilmiyorsam yazmami istedigin asagida kodlardaki senaryoyu kurgulayabilirmiyim acaba?
(Simdiki ornekte de tek cycle'da bit banding yaptim. Yani, 8 bit icindeki her hangi bir biti tec cycle'da cekip cikarttim)

Ilk kez, bitbandingi tek cycle da yaptigimi telafuz ettigim mesaji asagiya alintiladim. Acaba bu adam orneginde ne yapmis ta tek cycle da bitbanding yaptigini iddia ediyor dedin mi acaba?

Linkini verdiğim programda init aşaması geçildikten sonra, bit atamalarını sadece tek makine cycle'ında yapıyor.

Örneğin 10 adet biti tek tek set yada reset edeceksen bu sadece 10 makine cycle'ı demek. Bundan daha hızlı bit manuplasyonu da olmaz. (Her clockta bir bit set yada reset)

Burada tek makine cycle'inda bit banding yaptigimi iddia ettigim ornege bir bak lutfen. Soz konusu mesajimda,  [/color]init aşaması geçildikten sonra, bit atamalarını sadece tek makine cycle'ında yapıyor da demistim. Yani, while icinde 3..4 satirlik initialize islemi bittikten sonra dan da bahsetmisim.

Fakat bu vurgularimi gormemezlikten gelip hemen hemen her mesajinda (asagidaki mesajinda oldugu gibi) "her sart ve kosulda, bitbangi 1 cycle da" yapabilecegimi iddia etmisim gibi sozlerimi genellemeye calisiyorsun.

..... Diyosun ki "bit dandik" tek saykılda çalışıyor bende sana gerçek register adreslerini kullanarak hızlı çalışmasını bana ispatla dedim.

Gordugun gibi soylemedigim ustelik tamamen sana ait sozleri sanki benim sozlerimmis gibi bana itham ediyorsun.

Senin butun derdin asagidaki iddiani gecersiz kilmis olmam.

Bit Banding'i keil ve iar'da denemiştim, zamanlama anlamında büyük bir avantaj getirmiyor. Maskele ile aynı sonuçları almıştım. Ama tabii belki sizi bit maskelemekten kurtarır fakat aynı şeyi güzel bir macro ile sizde yazabilirsiniz.

Gecmisteki mesajlarimda C ye cok atip tuttum, su anda C yi ovuyor da degilim. C diliyle kod da yazarim fakat C, kafamdan gecen herseyi ozgurce kodlamama izin vermiyor yada ben beceremiyorum. Asagidaki C'nin main fonksiyonuna yazdigim kodlari malesef C satirlarina dokemem. Bu kodlari urettirecek C kodlarini sanirim sen ileri C bilginle yazabilirsin.

Aşağıya yazdım , hemde low optimizasyon seviyesinde yazdım. Senin gibi 2 tane biti while içine alıp hazırlama kısımlarını while dışında bırakan level 3 optimizasyon kullanmadan. Topu topu 20 tane asm komutu yetti de arttı bile. Hemde yazdığım kodda tüm parametreler değiştirilebilir, anlaşılır , 32bit sayılarla uğraşmadan ve hızlı.

Şimdi yukarıda söylediğin gibi bana bitbanding'in avantajını hemen göster. (sözlerle değil asm ile)

Emredersin. C satirlarim asagida.

[/color]#include "STM32F4xx.h"

void SystemInit()
{
}

volatile unsigned char A[]={1,7,0};

int __asm main()
{
     PUSH  {R4-R9} 
     LDR     R9,=__cpp((unsigned)&A)
     MOV    R1,#0x22000000
     ADD    R8,R1,R9,LSL #5
     LDM    R8!,{R0-R7}
     LDM    R8!,{R4-R7}
     ORR    R7,R2,LSL #1
     ORR    R7,R5,LSL #2
     ORR    R7,R0,LSL #3
     ORR    R7,R6,LSL #4
     ORR    R7,R1,LSL #5
     ORR    R7,R4,LSL #6
     ORR    R7,R3,LSL #7
     STR    R7,[R9,#2]
     POP    {R4-R9}
}

ASM ciktisi da asagida.

    11:         PUSH  {R4-R9}   
0x08000238 E92D03F0  PUSH          {r4-r9}
    12:     LDR   R9,=__cpp((unsigned)&A) 
0x0800023C F8DF9034  LDR.W         r9,[pc,#52]  ; @0x08000274
    13:     MOV   R1,#0x22000000 
0x08000240 F04F5108  MOV           r1,#0x22000000
    14:     ADD   R8,R1,R9,LSL #5 
0x08000244 EB011849  ADD           r8,r1,r9,LSL #5
    15:         LDM   R8!,{R0-R7} 
0x08000248 E8B800FF  LDM           r8!,{r0-r7}
    16:         LDM   R8!,{R4-R7} 
0x0800024C E8B800F0  LDM           r8!,{r4-r7}
    17:         ORR   R7,R2,LSL #1 
0x08000250 EA470742  ORR           r7,r7,r2,LSL #1
    18:         ORR       R7,R5,LSL #2 
0x08000254 EA470785  ORR           r7,r7,r5,LSL #2
    19:         ORR       R7,R0,LSL #3 
0x08000258 EA4707C0  ORR           r7,r7,r0,LSL #3
    20:         ORR       R7,R6,LSL #4 
0x0800025C EA471706  ORR           r7,r7,r6,LSL #4
    21:         ORR       R7,R1,LSL #5 
0x08000260 EA471741  ORR           r7,r7,r1,LSL #5
    22:         ORR       R7,R4,LSL #6 
0x08000264 EA471784  ORR           r7,r7,r4,LSL #6
    23:         ORR       R7,R3,LSL #7 
0x08000268 EA4717C3  ORR           r7,r7,r3,LSL #7
    24:         STR       R7,[R9,#2] 
0x0800026C F8C97002  STR           r7,[r9,#0x02]
    25:         POP   {R4-R9} 
0x08000270 E8BD03F0  POP           {r4-r9}

Kriter olarak bindbanding kullanimini sart kostugun ve asm kodlarin sayisina taktigin icin, sana 15 opcode luk + bitbanding calisan program yazdim. Buda senin ovundugun 20 satirlik koda gore %25 daha az satir demek. Kodlarim, bitbandingin ezici ustunlugunu ne kadar gosterir bilmiyorum fakat ezici ustunlugu gormek istersen son soruma cevap olacak kodlari yazmani istiyorum.

Tum bunlardan sonra, bir ozur hakettigimi dusunuyorum. Cunku, En tepeye yerlestirdigim alintinin iceriginde oldugu gibi dogrudan kisilere degil yanlis fikirlere saldirmamalisin.

[z]

vayyy ,neden? Bu işin pipeline ile alakası var mı? Belki alakası bile olmayabilir ama okuduğum şeyleri bağlantılamaya oturtmaya çalışıyorum. 

Hayir bunun pipeline ile hic alakasi yok. ARM mimarisinde CPU registerleri cok fazla. Herhangi bir amaci gerceklestirecek tek satirlik kod yazilirken ihtiyac olunan degerler eger CPU registerlerinin icinde zaten hazirda varsa, bu deger tekrardan register icine kodla yerlestirilmez var olan registerler o anki komutun parametresi olarak kullaniliverir.

Ornegin

Bir onceki satirda y=A+B islemini yaptiysan, bir sonraki satirda da G=Y+B islemi yapacaksan

ilk satirda  Y = A + B de , Y, A , B yi fakli registerlerde tutarsin. Ardindan gelen G = Y + B icin Y ve B yi yeniden registerlere yerlestirmeye calismaz zaten regisyerlerde hazir olan Y ve B yi toplayiverirsin.

Bu nedenle, registerler ne sakliyordu, simdi registerlere ne yuklemeliyim gelecekte ne saklamali, hangisi register icerigi feda edilmeli sorularinin cevabi ARM icin optimize kodlarin olusturulmasinda cok onemlidir. Malesef bunu asm yazimda tamamen siz kurgularken C derleyicisinin optimizasyon yetenegi belirler.

Bu nedenle C kodlarinin optimize edilmis ASM ciktilarina dikkat ederseniz, ornegin programin pek cok yerinde gecen Y=A+B islemine karsilik gelen asm kodlarin her defasinda farkli CPU registerleri uzerinden yurutuldugunu gorursunuz.

Bu nedenle Y=A+B bazen 1 cycle da bazen de 4 cycle da isletilir.

Ozellikle de ARM islemci icin, C de yazilan bir komut parcasinin kac cycle tutacagindan asla emin olamazsiniz.

Zaten bitbanding konusunun uzamasina sebep olan yok 1 cycle di yok 3 cycle di tartismasinin altinda da benzer sebepler var.

[CLR]

Şimdi yukarıda yazdığın C programlama dili mi? Programı C içinde "asm bloğu" olarak yazıp buna C mi diyorsun? Eğer bu C programlama dili ise portable olması gerekir şimdi bunu GCC, iar, Raisonance'da derle veya arm veya arm cortex m3 olmayan başka bir işlemcide ama noktasına kadar değiştirmeden. Derlerseler sen haklısın diyeceğim ve özür dileceğim.

Benim istediğim cevap bu değil, doğrudan C keyword'leri ile ve bitbanding ile bana bu programı yaz.

[z]

Neyse gel tatliya baglayalim. Bitirelim bu konuyu. Ozur de beklemiyorum.

Verdigim ASM program kisaliginda sonuc uretecek seviyede C bilmiyorum. Fakat bu asm kodlar, en azindan cok eski zamanlardaki  C-ASM tartismalarina yeterli cevap olmustur.

Kodlari bu haliyle Keil haricindeki diger derleyicilerde derlemeye kalkarsak sorun cikartabilir.  Fakat sorunu cikartacak kisim, asm kodlar degil, __asm ve _CPP olan C tanimlayicilari olabilir. Belli basli platformlarda sorunsuz derlenebilmesi icin bir header dosyaya, derleyici IAR ise su eki kullan, Keil ise su eki kullan seklinde #ifdef ile tanimlamalar yapiliyor. Bu gune kadar hic bir zaman, tasinabilir kod yazimi amaci gutmedigimden verdigim koda da bu tur tanimlamalar eklemedim fakat istersen ugrasirim zor bir sey degil cunku.

Yeni tartismalar baslatmamasi icin hemen belirtmeliyim ki verdigim kodlari, hizli kossun diye degil sirf kisa olmasini istedigin icin bu sekilde yazdim.

[mcan]

@Bunalmis sizin bahsettiğinizi denemeye çalıştım ,evet sonuçler bu şekilde

  89:                 PortC.Pin5 = 1;
    90:          //else
0x080002CC F04F0001  MOV      r0,#0x01
0x080002D0 4924      LDR      r1,[pc,#144]  ; @0x08000364
0x080002D2 F8C10188  STR      r0,[r1,#0x188]
    91:                 portc.Pin9 = 1;
0x080002D6 4824      LDR      r0,[pc,#144]  ; @0x08000368
0x080002D8 6800      LDR      r0,[r0,#0x00]
0x080002DA F4207000  BIC      r0,r0,#0x200
0x080002DE F5007000  ADD      r0,r0,#0x200
0x080002E2 4921      LDR      r1,[pc,#132]  ; @0x08000368
0x080002E4 6008      STR      r0,[r1,#0x00]
    92:                 PortC.Pin5 = 1;
0x080002E6 F04F0001  MOV      r0,#0x01
0x080002EA 491E      LDR      r1,[pc,#120]  ; @0x08000364
0x080002EC F8C10188  STR      r0,[r1,#0x188]
    93:                 portc.Pin9 = 1;
0x080002F0 481D      LDR      r0,[pc,#116]  ; @0x08000368
0x080002F2 6800      LDR      r0,[r0,#0x00]
0x080002F4 F4207000  BIC      r0,r0,#0x200
0x080002F8 F5007000  ADD      r0,r0,#0x200
0x080002FC 491A      LDR      r1,[pc,#104]  ; @0x08000368
0x080002FE 6008      STR      r0,[r1,#0x00]
   94:                 portc.Pin9 = 1;
0x08000300 4608      MOV      r0,r1
0x08000302 6800      LDR      r0,[r0,#0x00]
0x08000304 F4207000  BIC      r0,r0,#0x200
0x08000308 F5007000  ADD      r0,r0,#0x200
0x0800030C 6008      STR      r0,[r1,#0x00]
    95:                 PortC.Pin5 = 1;
0x0800030E F04F0001  MOV      r0,#0x01
0x08000312 4914      LDR      r1,[pc,#80]  ; @0x08000364
0x08000314 F8C10188  STR      r0,[r1,#0x188]
    96:                 PortC.Pin5 = 1;
0x08000318 F8C10188  STR      r0,[r1,#0x188]

Ard arda gelmedikçe fazla kısalma olmuyor ama ard- arda gelinc bit banding tek komuta ,maskeleme ise 5 komuta düşüyor....


Bitbanding ile maskeleme yöntemini karşılaştırmaya çalışıyorum.

Yazdığım kod budur

#include "STM32F10x.h"


#define BIT_LEVEL_SRAM(a,b) ((SRAM_BB_BASE + (a-SRAM_BASE)*32 + (b*4)))
#define BIT_LEVEL_PERI(a,b) ((PERIPH_BB_BASE + (a-PERIPH_BASE)*32 + (b*4)))
#define	RCC_APB2ENR	(RCC_BASE+0x018)

#define GPIO_C_ENABLE *((volatile unsigned int *)(BIT_LEVEL_PERI(RCC_APB2ENR,4)))

void delay(unsigned int);
static int ih;
int zg,ipb,ii;

typedef struct {
  int Pin0 : 1;
  int Pin1 : 1;
  int Pin2 : 1;
  int Pin3 : 1;
  int Pin4 : 1;
  int Pin5 : 1;
  int Pin6 : 1;
  int Pin7 : 1;
  int Pin8 : 1;
  int Pin9 : 1;
} BB __attribute__((bitband));

BB PortC __attribute__((at(GPIOC_BASE+0x0C)));

typedef struct {
  int Pin0 : 1;
  int Pin1 : 1;
  int Pin2 : 1;
  int Pin3 : 1;
  int Pin4 : 1;
  int Pin5 : 1;
  int Pin6 : 1;
  int Pin7 : 1;
  int Pin8 : 1;
  int Pin9 : 1;
} BM;

BM portc __attribute__((at(GPIOC_BASE+0x0C)));

void TIM7_IRQHandler(void)
{	
	ih =!ih ;

	while(TIM7->SR)
	{
		TIM7->SR  = 0x0;
	}
	
}

void SystemInit (void)
{
	delay(0x880000);
	GPIO_C_ENABLE = 1 ;
 	//RCC->APB2ENR |= 0x00000016;    // GPIOD donanımının clock sinyalini uygulayalım
    GPIOC->CRL = 0x37333333;     // GPIOD nin 15, 14, 13, 12 pinleri cikis tanimlandi (Ledler bu pinlerde)
	GPIOC->CRH = 0x33333333;

	RCC->CR |= 0x0010000;	   			// HSE ON
	RCC->CFGR = 0x001D0000;	   			// PLL ayarla
	RCC->CR  |= 0x001000000;	   		// PLL aç
	FLASH->ACR =  0x32;					// Flash gecikme ayarı
	RCC->CFGR = 0x001D0702;	   			// SİNYAL KAYNAĞI PLL	 APB1 HCLK/16

	RCC->APB1ENR |= 0x00000020;		    //Timer7 ye clock verelim
	TIM7->DIER = 0x1;
	TIM7->PSC = 0x1FF;			  		//182=B6  182*5= H393
	TIM7->ARR = 0xFFFF;
	TIM7->CR1  = 0x85;
	NVIC->ISER[1] = 0X00800000;        // NVIC de Timer 7 interrupta izin verelim

} 
																										   
void delay(unsigned int i)
{   unsigned int z;
    for(z=0;z<i;z++);
	 
}
 
int main()
{
    while(1)
   {
	//if(ih)
	 	PortC.Pin5 = 1;		//GPIOC->ODR= 0x20;     // Ledler yansin
	 //else
		portc.Pin9 = 1;		//GPIOC->ODR= 0x200;     // Ledler yansin
	 delay(0x40000);
     GPIOC->ODR = 0x00;     // Ledler sonsun
	 delay(0x40000);
   } 
}

Üretilen asm kod bu şekilde;

89:                 PortC.Pin5 = 1;                //GPIOC->ODR= 0x20;     // Ledler yansin
    90:          //else
0x080002CC F04F0001  MOV      r0,#0x01
0x080002D0 4916      LDR      r1,[pc,#88]  ; @0x0800032C
0x080002D2 F8C10188  STR      r0,[r1,#0x188]
    91:                 portc.Pin9 = 1;  //GPIOC->ODR= 0x200;     // Ledler yansin
0x080002D6 4816      LDR      r0,[pc,#88]  ; @0x08000330
0x080002D8 6800      LDR      r0,[r0,#0x00]
0x080002DA F4207000  BIC      r0,r0,#0x200
0x080002DE F5007000  ADD      r0,r0,#0x200
0x080002E2 4913      LDR      r1,[pc,#76]  ; @0x08000330
0x080002E4 6008      STR      r0,[r1,#0x00]

Şimdi kırmızı bit banding e ait olduğunu düşündüğüm kodlar ve mavi ise maskeleme yöntemi.


3 adet Kırmızı kod, 6 adet mavi kod var... Eğer ki pinlere sabit değilde değişken üzerinden veri aktarırsak; 4 adet Kırmızı koda karşılık 7 adet mavi kod oluşuyor.

@Eemkutay sizin anlatmak istediğinizi konuya hakim olmadığımdan tam anlayamadım.Koda bakarak yöntemler arasında en az 3 kod sayısınca farkın olduğunu düşünüyorum ,acaba bu fark derleyicinin optimizasyonunun düşük olduğundanmı yoksa arada hiç fark yok mu?