📄 osal_memory.s51
字号:
// 241 void *osal_mem_alloc( uint16 size )
osal_mem_alloc:
CFI Block cfiBlock6 Using cfiCommon0
CFI Function osal_mem_alloc
// 242 {
FUNCALL osal_mem_alloc, osal_mem_init
LOCFRAME XSTACK, 14, STACK
ARGFRAME XSTACK, 14, STACK
MOV A,#-0xe
LCALL ?BANKED_ENTER_XDATA
CFI DPH0 load(1, XDATA, add(CFA_XSP16, literal(-1)))
CFI DPL0 load(1, XDATA, add(CFA_XSP16, literal(-2)))
CFI ?BRET_EXT load(1, XDATA, add(CFA_XSP16, literal(-3)))
CFI ?RET_HIGH load(1, XDATA, add(CFA_XSP16, literal(-4)))
CFI ?RET_LOW load(1, XDATA, add(CFA_XSP16, literal(-5)))
CFI R7 load(1, XDATA, add(CFA_XSP16, literal(-6)))
CFI V5 load(1, XDATA, add(CFA_XSP16, literal(-7)))
CFI V4 load(1, XDATA, add(CFA_XSP16, literal(-8)))
CFI V3 load(1, XDATA, add(CFA_XSP16, literal(-9)))
CFI V2 load(1, XDATA, add(CFA_XSP16, literal(-10)))
CFI V1 load(1, XDATA, add(CFA_XSP16, literal(-11)))
CFI V0 load(1, XDATA, add(CFA_XSP16, literal(-12)))
CFI VB load(1, XDATA, add(CFA_XSP16, literal(-13)))
CFI R6 load(1, XDATA, add(CFA_XSP16, literal(-14)))
CFI CFA_SP SP+0
CFI CFA_XSP16 add(XSP16, 14)
; Saved register size: 14
; Auto size: 0
MOV ?V0 + 0,R2
MOV ?V0 + 1,R3
// 243 osalMemHdr_t *prev;
// 244 osalMemHdr_t *hdr;
// 245 halIntState_t intState;
// 246 uint16 tmp;
// 247 byte coal = 0;
MOV ?V0 + 2,#0x0
// 248
// 249 #if ( OSALMEM_GUARD )
// 250 // Try to protect against premature use by HAL / OSAL.
// 251 if ( ready != OSALMEM_READY )
MOV DPTR,#??ready
MOVX A,@DPTR
XRL A,#0xe2
JZ ??osal_mem_alloc_0
// 252 {
// 253 osal_mem_init();
; Setup parameters for call to function osal_mem_init
MOV DPTR,#(osal_mem_init & 0xffff)
MOV A,#((osal_mem_init >> 16) & 0xff)
LCALL ?BCALL ; Banked call to: DPTR()
// 254 }
// 255 #endif
// 256
// 257 OSALMEM_ASSERT( size );
// 258
// 259 size += HDRSZ;
??osal_mem_alloc_0:
MOV A,?V0 + 0
ADD A,#0x2
MOV ?V0 + 0,A
MOV A,?V0 + 1
ADDC A,#0x0
MOV ?V0 + 1,A
// 260
// 261 // Calculate required bytes to add to 'size' to align to halDataAlign_t.
// 262 if ( sizeof( halDataAlign_t ) == 2 )
// 263 {
// 264 size += (size & 0x01);
// 265 }
// 266 else if ( sizeof( halDataAlign_t ) != 1 )
// 267 {
// 268 const byte mod = size % sizeof( halDataAlign_t );
// 269
// 270 if ( mod != 0 )
// 271 {
// 272 size += (sizeof( halDataAlign_t ) - mod);
// 273 }
// 274 }
// 275
// 276 HAL_ENTER_CRITICAL_SECTION( intState ); // Hold off interrupts.
MOV C,0xa8.7
CLR A
MOV 0xE0 /* A */.0,C
MOV R4,A
CLR 0xa8.7
// 277
// 278 // Smaller allocations are first attempted in the small-block bucket.
// 279 if ( size <= OSALMEM_SMALL_BLKSZ )
CLR C
MOV A,?V0 + 0
SUBB A,#0x11
MOV A,?V0 + 1
SUBB A,#0x0
JNC ??osal_mem_alloc_1
// 280 {
// 281 hdr = ff1;
MOV DPTR,#??ff1
SJMP ??osal_mem_alloc_2
// 282 }
// 283 else
// 284 {
// 285 hdr = ff2;
??osal_mem_alloc_1:
MOV DPTR,#??ff2
??osal_mem_alloc_2:
MOVX A,@DPTR
MOV R2,A
INC DPTR
MOVX A,@DPTR
LCALL ?Subroutine1 & 0xFFFF
// 286 }
// 287 tmp = *hdr;
// 288
// 289 do
// 290 {
// 291 if ( tmp & OSALMEM_IN_USE )
??CrossCallReturnLabel_2:
MOV A,#-0x80
ANL A,R1
MOV ?V0 + 5,A
CLR A
JNZ ??osal_mem_alloc_3
MOV A,?V0 + 5
??osal_mem_alloc_3:
JZ ??osal_mem_alloc_4
// 292 {
// 293 tmp ^= OSALMEM_IN_USE;
MOV A,#-0x80
XRL A,R1
MOV R1,A
// 294 coal = 0;
MOV ?V0 + 2,#0x0
SJMP ??osal_mem_alloc_5
// 295 }
// 296 else
// 297 {
// 298 if ( coal != 0 )
??osal_mem_alloc_4:
MOV A,?V0 + 2
JZ ??osal_mem_alloc_6
// 299 {
// 300 #if ( OSALMEM_METRICS )
// 301 blkCnt--;
// 302 blkFree--;
// 303 #endif
// 304
// 305 *prev += *hdr;
MOV DPL,R2
MOV DPH,R3
MOVX A,@DPTR
MOV ?V0 + 4,A
INC DPTR
MOVX A,@DPTR
MOV ?V0 + 5,A
MOV DPL,R6
MOV DPH,R7
MOVX A,@DPTR
ADD A,?V0 + 4
MOVX @DPTR,A
INC DPTR
MOVX A,@DPTR
ADDC A,?V0 + 5
MOVX @DPTR,A
// 306
// 307 if ( *prev >= size )
MOV DPL,R6
MOV DPH,R7
CLR C
MOVX A,@DPTR
SUBB A,?V0 + 0
INC DPTR
MOVX A,@DPTR
SUBB A,?V0 + 1
JC ??osal_mem_alloc_5
// 308 {
// 309 hdr = prev;
MOV A,R6
MOV R2,A
MOV A,R7
LCALL ?Subroutine1 & 0xFFFF
// 310 tmp = *hdr;
// 311 break;
// 312 }
// 313 }
// 314 else
// 315 {
// 316 if ( tmp >= size )
// 317 {
// 318 break;
// 319 }
// 320
// 321 coal = 1;
// 322 prev = hdr;
// 323 }
// 324 }
// 325
// 326 hdr = (osalMemHdr_t *)((byte *)hdr + tmp);
// 327
// 328 tmp = *hdr;
// 329 if ( tmp == 0 )
// 330 {
// 331 hdr = NULL;
// 332 break;
// 333 }
// 334
// 335
// 336 } while ( 1 );
// 337
// 338 if ( hdr != NULL )
??CrossCallReturnLabel_3:
MOV A,R2
JNZ ??osal_mem_alloc_7
MOV A,R3
??osal_mem_alloc_7:
JZ ??osal_mem_alloc_8
// 339 {
// 340 tmp -= size;
CLR C
MOV A,R0
SUBB A,?V0 + 0
MOV R0,A
MOV A,R1
SUBB A,?V0 + 1
MOV R1,A
// 341
// 342 // Determine whether the threshold for splitting is met.
// 343 if ( tmp >= OSALMEM_MIN_BLKSZ )
CLR C
MOV A,R0
SUBB A,#0x4
MOV A,R1
SUBB A,#0x0
JC ??osal_mem_alloc_9
// 344 {
// 345 // Split the block before allocating it.
// 346 osalMemHdr_t *next = (osalMemHdr_t *)((byte *)hdr + size);
// 347 *next = tmp;
MOV A,R2
ADD A,?V0 + 0
MOV DPL,A
MOV A,R3
ADDC A,?V0 + 1
MOV DPH,A
MOV A,R0
MOVX @DPTR,A
INC DPTR
MOV A,R1
MOVX @DPTR,A
// 348 *hdr = (size | OSALMEM_IN_USE);
MOV A,#-0x80
ORL A,?V0 + 1
MOV R1,A
MOV DPL,R2
MOV DPH,R3
MOV A,?V0 + 0
MOVX @DPTR,A
INC DPTR
MOV A,R1
SJMP ??osal_mem_alloc_10
// 349
// 350 #if ( OSALMEM_METRICS )
// 351 blkCnt++;
// 352 if ( blkMax < blkCnt )
// 353 {
// 354 blkMax = blkCnt;
// 355 }
// 356 memAlo += size;
// 357 #endif
// 358 }
??osal_mem_alloc_6:
CLR C
MOV A,R0
SUBB A,?V0 + 0
MOV A,R1
SUBB A,?V0 + 1
JNC ??CrossCallReturnLabel_3
MOV ?V0 + 2,#0x1
MOV A,R2
MOV R6,A
MOV A,R3
MOV R7,A
??osal_mem_alloc_5:
MOV A,R2
ADD A,R0
MOV R2,A
MOV A,R3
ADDC A,R1
LCALL ?Subroutine1 & 0xFFFF
??CrossCallReturnLabel_4:
MOV A,R0
JNZ ??osal_mem_alloc_11
MOV A,R1
??osal_mem_alloc_11:
JZ $+5
LJMP ??CrossCallReturnLabel_2 & 0xFFFF
MOV R2,#0x0
MOV R3,#0x0
SJMP ??osal_mem_alloc_8
// 359 else
// 360 {
// 361 #if ( OSALMEM_METRICS )
// 362 memAlo += *hdr;
// 363 blkFree--;
// 364 #endif
// 365
// 366 *hdr |= OSALMEM_IN_USE;
??osal_mem_alloc_9:
MOV DPL,R2
MOV DPH,R3
MOVX A,@DPTR
MOVX @DPTR,A
INC DPTR
MOVX A,@DPTR
ORL A,#0x80
??osal_mem_alloc_10:
MOVX @DPTR,A
// 367 }
// 368
// 369 #if ( OSALMEM_METRICS )
// 370 if ( memMax < memAlo )
// 371 {
// 372 memMax = memAlo;
// 373 }
// 374 #endif
// 375
// 376 #if ( OSALMEM_PROFILER )
// 377 {
// 378 byte idx;
// 379 size = *hdr ^ OSALMEM_IN_USE;
// 380
// 381 for ( idx = 0; idx < OSALMEM_PROMAX; idx++ )
// 382 {
// 383 if ( size <= proCnt[idx] )
// 384 {
// 385 break;
// 386 }
// 387 }
// 388 proCur[idx]++;
// 389 if ( proMax[idx] < proCur[idx] )
// 390 {
// 391 proMax[idx] = proCur[idx];
// 392 }
// 393 proTot[idx]++;
// 394 }
// 395 #endif
// 396
// 397 hdr++;
MOV A,R2
ADD A,#0x2
INC R2
INC R2
MOV A,R3
ADDC A,#0x0
MOV R3,A
// 398
// 399 #if ( OSALMEM_PROFILER )
// 400 osal_memset( (byte *)hdr, OSALMEM_ALOC, (size - HDRSZ) );
// 401
// 402 /* A small-block could not be allocated in the small-block bucket.
// 403 * When this occurs significantly frequently, increase the size of the
// 404 * bucket in order to restore better worst case run times. Set the first
// 405 * profiling bucket size in proCnt[] to the small-block bucket size and
// 406 * divide proSmallBlkMiss by the corresponding proTot[] size to get % miss.
// 407 * Best worst case time on TrasmitApp was achieved at a 0-15% miss rate
// 408 * during steady state Tx load, 0% during idle and steady state Rx load.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -