2 Implementation of Multiple Processor PPI services.
4 Copyright (c) 2015, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "PeiMpServices.h"
19 Get CPU Package/Core/Thread location information.
21 @param InitialApicId CPU APIC ID
22 @param Location Pointer to CPU location information
25 ExtractProcessorLocation (
26 IN UINT32 InitialApicId
,
27 OUT EFI_CPU_PHYSICAL_LOCATION
*Location
30 BOOLEAN TopologyLeafSupported
;
40 UINT32 MaxLogicProcessorsPerPackage
;
41 UINT32 MaxCoresPerPackage
;
44 // Check if the processor is capable of supporting more than one logical processor.
46 AsmCpuid (CPUID_VERSION_INFO
, NULL
, NULL
, NULL
, &RegEdx
);
47 if ((RegEdx
& BIT28
) == 0) {
50 Location
->Package
= 0;
58 // Assume three-level mapping of APIC ID: Package:Core:SMT.
61 TopologyLeafSupported
= FALSE
;
63 // Get the max index of basic CPUID
65 AsmCpuid (CPUID_SIGNATURE
, &MaxCpuIdIndex
, NULL
, NULL
, NULL
);
68 // If the extended topology enumeration leaf is available, it
69 // is the preferred mechanism for enumerating topology.
71 if (MaxCpuIdIndex
>= CPUID_EXTENDED_TOPOLOGY
) {
72 AsmCpuidEx (CPUID_EXTENDED_TOPOLOGY
, 0, &RegEax
, &RegEbx
, &RegEcx
, NULL
);
74 // If CPUID.(EAX=0BH, ECX=0H):EBX returns zero and maximum input value for
75 // basic CPUID information is greater than 0BH, then CPUID.0BH leaf is not
76 // supported on that processor.
79 TopologyLeafSupported
= TRUE
;
82 // Sub-leaf index 0 (ECX= 0 as input) provides enumeration parameters to extract
83 // the SMT sub-field of x2APIC ID.
85 LevelType
= (RegEcx
>> 8) & 0xff;
86 ASSERT (LevelType
== CPUID_EXTENDED_TOPOLOGY_LEVEL_TYPE_SMT
);
87 ThreadBits
= RegEax
& 0x1f;
90 // Software must not assume any "level type" encoding
91 // value to be related to any sub-leaf index, except sub-leaf 0.
95 AsmCpuidEx (CPUID_EXTENDED_TOPOLOGY
, SubIndex
, &RegEax
, NULL
, &RegEcx
, NULL
);
96 LevelType
= (RegEcx
>> 8) & 0xff;
97 if (LevelType
== CPUID_EXTENDED_TOPOLOGY_LEVEL_TYPE_CORE
) {
98 CoreBits
= (RegEax
& 0x1f) - ThreadBits
;
102 } while (LevelType
!= CPUID_EXTENDED_TOPOLOGY_LEVEL_TYPE_INVALID
);
106 if (!TopologyLeafSupported
) {
107 AsmCpuid (CPUID_VERSION_INFO
, NULL
, &RegEbx
, NULL
, NULL
);
108 MaxLogicProcessorsPerPackage
= (RegEbx
>> 16) & 0xff;
109 if (MaxCpuIdIndex
>= CPUID_CACHE_PARAMS
) {
110 AsmCpuidEx (CPUID_CACHE_PARAMS
, 0, &RegEax
, NULL
, NULL
, NULL
);
111 MaxCoresPerPackage
= (RegEax
>> 26) + 1;
114 // Must be a single-core processor.
116 MaxCoresPerPackage
= 1;
119 ThreadBits
= (UINTN
) (HighBitSet32 (MaxLogicProcessorsPerPackage
/ MaxCoresPerPackage
- 1) + 1);
120 CoreBits
= (UINTN
) (HighBitSet32 (MaxCoresPerPackage
- 1) + 1);
123 Location
->Thread
= InitialApicId
& ~((-1) << ThreadBits
);
124 Location
->Core
= (InitialApicId
>> ThreadBits
) & ~((-1) << CoreBits
);
125 Location
->Package
= (InitialApicId
>> (ThreadBits
+ CoreBits
));
129 Find the current Processor number by APIC ID.
131 @param PeiCpuMpData Pointer to PEI CPU MP Data
132 @param ProcessorNumber Return the pocessor number found
134 @retval EFI_SUCCESS ProcessorNumber is found and returned.
135 @retval EFI_NOT_FOUND ProcessorNumber is not found.
139 IN PEI_CPU_MP_DATA
*PeiCpuMpData
,
140 OUT UINTN
*ProcessorNumber
143 UINTN TotalProcessorNumber
;
146 TotalProcessorNumber
= PeiCpuMpData
->CpuCount
;
147 for (Index
= 0; Index
< TotalProcessorNumber
; Index
++) {
148 if (PeiCpuMpData
->CpuData
[Index
].ApicId
== GetInitialApicId ()) {
149 *ProcessorNumber
= Index
;
153 return EFI_NOT_FOUND
;
157 This service retrieves the number of logical processor in the platform
158 and the number of those logical processors that are enabled on this boot.
159 This service may only be called from the BSP.
161 This function is used to retrieve the following information:
162 - The number of logical processors that are present in the system.
163 - The number of enabled logical processors in the system at the instant
166 Because MP Service Ppi provides services to enable and disable processors
167 dynamically, the number of enabled logical processors may vary during the
168 course of a boot session.
170 If this service is called from an AP, then EFI_DEVICE_ERROR is returned.
171 If NumberOfProcessors or NumberOfEnabledProcessors is NULL, then
172 EFI_INVALID_PARAMETER is returned. Otherwise, the total number of processors
173 is returned in NumberOfProcessors, the number of currently enabled processor
174 is returned in NumberOfEnabledProcessors, and EFI_SUCCESS is returned.
176 @param[in] PeiServices An indirect pointer to the PEI Services Table
177 published by the PEI Foundation.
178 @param[in] This Pointer to this instance of the PPI.
179 @param[out] NumberOfProcessors Pointer to the total number of logical processors in
180 the system, including the BSP and disabled APs.
181 @param[out] NumberOfEnabledProcessors
182 Number of processors in the system that are enabled.
184 @retval EFI_SUCCESS The number of logical processors and enabled
185 logical processors was retrieved.
186 @retval EFI_DEVICE_ERROR The calling processor is an AP.
187 @retval EFI_INVALID_PARAMETER NumberOfProcessors is NULL.
188 NumberOfEnabledProcessors is NULL.
192 PeiGetNumberOfProcessors (
193 IN CONST EFI_PEI_SERVICES
**PeiServices
,
194 IN EFI_PEI_MP_SERVICES_PPI
*This
,
195 OUT UINTN
*NumberOfProcessors
,
196 OUT UINTN
*NumberOfEnabledProcessors
199 PEI_CPU_MP_DATA
*PeiCpuMpData
;
201 UINTN ProcessorNumber
;
202 UINTN EnabledProcessorNumber
;
205 PeiCpuMpData
= GetMpHobData ();
206 if (PeiCpuMpData
== NULL
) {
207 return EFI_NOT_FOUND
;
210 if ((NumberOfProcessors
== NULL
) || (NumberOfEnabledProcessors
== NULL
)) {
211 return EFI_INVALID_PARAMETER
;
215 // Check whether caller processor is BSP
217 PeiWhoAmI (PeiServices
, This
, &CallerNumber
);
218 if (CallerNumber
!= PeiCpuMpData
->BspNumber
) {
219 return EFI_DEVICE_ERROR
;
222 ProcessorNumber
= PeiCpuMpData
->CpuCount
;
223 EnabledProcessorNumber
= 0;
224 for (Index
= 0; Index
< ProcessorNumber
; Index
++) {
225 if (PeiCpuMpData
->CpuData
[Index
].State
!= CpuStateDisabled
) {
226 EnabledProcessorNumber
++;
230 *NumberOfProcessors
= ProcessorNumber
;
231 *NumberOfEnabledProcessors
= EnabledProcessorNumber
;
237 Gets detailed MP-related information on the requested processor at the
238 instant this call is made. This service may only be called from the BSP.
240 This service retrieves detailed MP-related information about any processor
241 on the platform. Note the following:
242 - The processor information may change during the course of a boot session.
243 - The information presented here is entirely MP related.
245 Information regarding the number of caches and their sizes, frequency of operation,
246 slot numbers is all considered platform-related information and is not provided
249 @param[in] PeiServices An indirect pointer to the PEI Services Table
250 published by the PEI Foundation.
251 @param[in] This Pointer to this instance of the PPI.
252 @param[in] ProcessorNumber Pointer to the total number of logical processors in
253 the system, including the BSP and disabled APs.
254 @param[out] ProcessorInfoBuffer Number of processors in the system that are enabled.
256 @retval EFI_SUCCESS Processor information was returned.
257 @retval EFI_DEVICE_ERROR The calling processor is an AP.
258 @retval EFI_INVALID_PARAMETER ProcessorInfoBuffer is NULL.
259 @retval EFI_NOT_FOUND The processor with the handle specified by
260 ProcessorNumber does not exist in the platform.
264 PeiGetProcessorInfo (
265 IN CONST EFI_PEI_SERVICES
**PeiServices
,
266 IN EFI_PEI_MP_SERVICES_PPI
*This
,
267 IN UINTN ProcessorNumber
,
268 OUT EFI_PROCESSOR_INFORMATION
*ProcessorInfoBuffer
271 PEI_CPU_MP_DATA
*PeiCpuMpData
;
274 PeiCpuMpData
= GetMpHobData ();
275 if (PeiCpuMpData
== NULL
) {
276 return EFI_NOT_FOUND
;
280 // Check whether caller processor is BSP
282 PeiWhoAmI (PeiServices
, This
, &CallerNumber
);
283 if (CallerNumber
!= PeiCpuMpData
->BspNumber
) {
284 return EFI_DEVICE_ERROR
;
287 if (ProcessorInfoBuffer
== NULL
) {
288 return EFI_INVALID_PARAMETER
;
291 if (ProcessorNumber
>= PeiCpuMpData
->CpuCount
) {
292 return EFI_NOT_FOUND
;
295 ProcessorInfoBuffer
->ProcessorId
= (UINT64
) PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
;
296 ProcessorInfoBuffer
->StatusFlag
= 0;
297 if (PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
== GetInitialApicId()) {
298 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_AS_BSP_BIT
;
300 if (PeiCpuMpData
->CpuData
[ProcessorNumber
].Health
.Uint32
== 0) {
301 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_HEALTH_STATUS_BIT
;
303 if (PeiCpuMpData
->CpuData
[ProcessorNumber
].State
== CpuStateDisabled
) {
304 ProcessorInfoBuffer
->StatusFlag
&= ~PROCESSOR_ENABLED_BIT
;
306 ProcessorInfoBuffer
->StatusFlag
|= PROCESSOR_ENABLED_BIT
;
310 // Get processor location information
312 ExtractProcessorLocation (PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
, &ProcessorInfoBuffer
->Location
);
318 This service executes a caller provided function on all enabled APs. APs can
319 run either simultaneously or one at a time in sequence. This service supports
320 both blocking requests only. This service may only
321 be called from the BSP.
323 This function is used to dispatch all the enabled APs to the function specified
324 by Procedure. If any enabled AP is busy, then EFI_NOT_READY is returned
325 immediately and Procedure is not started on any AP.
327 If SingleThread is TRUE, all the enabled APs execute the function specified by
328 Procedure one by one, in ascending order of processor handle number. Otherwise,
329 all the enabled APs execute the function specified by Procedure simultaneously.
331 If the timeout specified by TimeoutInMicroSeconds expires before all APs return
332 from Procedure, then Procedure on the failed APs is terminated. All enabled APs
333 are always available for further calls to EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
334 and EFI_PEI_MP_SERVICES_PPI.StartupThisAP(). If FailedCpuList is not NULL, its
335 content points to the list of processor handle numbers in which Procedure was
338 Note: It is the responsibility of the consumer of the EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
339 to make sure that the nature of the code that is executed on the BSP and the
340 dispatched APs is well controlled. The MP Services Ppi does not guarantee
341 that the Procedure function is MP-safe. Hence, the tasks that can be run in
342 parallel are limited to certain independent tasks and well-controlled exclusive
343 code. PEI services and Ppis may not be called by APs unless otherwise
346 In blocking execution mode, BSP waits until all APs finish or
347 TimeoutInMicroSeconds expires.
349 @param[in] PeiServices An indirect pointer to the PEI Services Table
350 published by the PEI Foundation.
351 @param[in] This A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
352 @param[in] Procedure A pointer to the function to be run on enabled APs of
354 @param[in] SingleThread If TRUE, then all the enabled APs execute the function
355 specified by Procedure one by one, in ascending order
356 of processor handle number. If FALSE, then all the
357 enabled APs execute the function specified by Procedure
359 @param[in] TimeoutInMicroSeconds
360 Indicates the time limit in microseconds for APs to
361 return from Procedure, for blocking mode only. Zero
362 means infinity. If the timeout expires before all APs
363 return from Procedure, then Procedure on the failed APs
364 is terminated. All enabled APs are available for next
365 function assigned by EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
366 or EFI_PEI_MP_SERVICES_PPI.StartupThisAP(). If the
367 timeout expires in blocking mode, BSP returns
369 @param[in] ProcedureArgument The parameter passed into Procedure for all APs.
371 @retval EFI_SUCCESS In blocking mode, all APs have finished before the
373 @retval EFI_DEVICE_ERROR Caller processor is AP.
374 @retval EFI_NOT_STARTED No enabled APs exist in the system.
375 @retval EFI_NOT_READY Any enabled APs are busy.
376 @retval EFI_TIMEOUT In blocking mode, the timeout expired before all
377 enabled APs have finished.
378 @retval EFI_INVALID_PARAMETER Procedure is NULL.
383 IN CONST EFI_PEI_SERVICES
**PeiServices
,
384 IN EFI_PEI_MP_SERVICES_PPI
*This
,
385 IN EFI_AP_PROCEDURE Procedure
,
386 IN BOOLEAN SingleThread
,
387 IN UINTN TimeoutInMicroSeconds
,
388 IN VOID
*ProcedureArgument OPTIONAL
391 PEI_CPU_MP_DATA
*PeiCpuMpData
;
392 UINTN ProcessorNumber
;
395 BOOLEAN HasEnabledAp
;
396 BOOLEAN HasEnabledIdleAp
;
397 volatile UINT32
*FinishedCount
;
399 UINTN WaitCountIndex
;
400 UINTN WaitCountNumber
;
402 PeiCpuMpData
= GetMpHobData ();
403 if (PeiCpuMpData
== NULL
) {
404 return EFI_NOT_FOUND
;
408 // Check whether caller processor is BSP
410 PeiWhoAmI (PeiServices
, This
, &CallerNumber
);
411 if (CallerNumber
!= PeiCpuMpData
->BspNumber
) {
412 return EFI_DEVICE_ERROR
;
415 ProcessorNumber
= PeiCpuMpData
->CpuCount
;
417 HasEnabledAp
= FALSE
;
418 HasEnabledIdleAp
= FALSE
;
419 for (Index
= 0; Index
< ProcessorNumber
; Index
++) {
420 if (Index
== CallerNumber
) {
426 if (PeiCpuMpData
->CpuData
[Index
].State
!= CpuStateDisabled
) {
428 if (PeiCpuMpData
->CpuData
[Index
].State
!= CpuStateBusy
) {
429 HasEnabledIdleAp
= TRUE
;
435 // If no enabled AP exists, return EFI_NOT_STARTED.
437 return EFI_NOT_STARTED
;
439 if (!HasEnabledIdleAp
) {
441 // If any enabled APs are busy, return EFI_NOT_READY.
443 return EFI_NOT_READY
;
446 WaitCountNumber
= TimeoutInMicroSeconds
/ CPU_CHECK_AP_INTERVAL
+ 1;
448 FinishedCount
= &PeiCpuMpData
->FinishedCount
;
450 WakeUpAP (PeiCpuMpData
, TRUE
, 0, Procedure
, ProcedureArgument
);
454 if (TimeoutInMicroSeconds
== 0) {
455 while (*FinishedCount
< ProcessorNumber
- 1) {
458 Status
= EFI_SUCCESS
;
460 Status
= EFI_TIMEOUT
;
461 for (WaitCountIndex
= 0; WaitCountIndex
< WaitCountNumber
; WaitCountIndex
++) {
462 MicroSecondDelay (CPU_CHECK_AP_INTERVAL
);
463 if (*FinishedCount
>= ProcessorNumber
- 1) {
464 Status
= EFI_SUCCESS
;
470 Status
= EFI_SUCCESS
;
471 for (Index
= 0; Index
< ProcessorNumber
; Index
++) {
472 if (Index
== CallerNumber
) {
475 WakeUpAP (PeiCpuMpData
, FALSE
, PeiCpuMpData
->CpuData
[Index
].ApicId
, Procedure
, ProcedureArgument
);
479 if (TimeoutInMicroSeconds
== 0) {
480 while (*FinishedCount
< 1) {
484 for (WaitCountIndex
= 0; WaitCountIndex
< WaitCountNumber
; WaitCountIndex
++) {
485 MicroSecondDelay (CPU_CHECK_AP_INTERVAL
);
486 if (*FinishedCount
>= 1) {
490 if (WaitCountIndex
== WaitCountNumber
) {
491 Status
= EFI_TIMEOUT
;
501 This service lets the caller get one enabled AP to execute a caller-provided
502 function. The caller can request the BSP to wait for the completion
503 of the AP. This service may only be called from the BSP.
505 This function is used to dispatch one enabled AP to the function specified by
506 Procedure passing in the argument specified by ProcedureArgument.
507 The execution is in blocking mode. The BSP waits until the AP finishes or
508 TimeoutInMicroSecondss expires.
510 If the timeout specified by TimeoutInMicroseconds expires before the AP returns
511 from Procedure, then execution of Procedure by the AP is terminated. The AP is
512 available for subsequent calls to EFI_PEI_MP_SERVICES_PPI.StartupAllAPs() and
513 EFI_PEI_MP_SERVICES_PPI.StartupThisAP().
515 @param[in] PeiServices An indirect pointer to the PEI Services Table
516 published by the PEI Foundation.
517 @param[in] This A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
518 @param[in] Procedure A pointer to the function to be run on enabled APs of
520 @param[in] ProcessorNumber The handle number of the AP. The range is from 0 to the
521 total number of logical processors minus 1. The total
522 number of logical processors can be retrieved by
523 EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
524 @param[in] TimeoutInMicroseconds
525 Indicates the time limit in microseconds for APs to
526 return from Procedure, for blocking mode only. Zero
527 means infinity. If the timeout expires before all APs
528 return from Procedure, then Procedure on the failed APs
529 is terminated. All enabled APs are available for next
530 function assigned by EFI_PEI_MP_SERVICES_PPI.StartupAllAPs()
531 or EFI_PEI_MP_SERVICES_PPI.StartupThisAP(). If the
532 timeout expires in blocking mode, BSP returns
534 @param[in] ProcedureArgument The parameter passed into Procedure for all APs.
536 @retval EFI_SUCCESS In blocking mode, specified AP finished before the
538 @retval EFI_DEVICE_ERROR The calling processor is an AP.
539 @retval EFI_TIMEOUT In blocking mode, the timeout expired before the
540 specified AP has finished.
541 @retval EFI_NOT_FOUND The processor with the handle specified by
542 ProcessorNumber does not exist.
543 @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP or disabled AP.
544 @retval EFI_INVALID_PARAMETER Procedure is NULL.
549 IN CONST EFI_PEI_SERVICES
**PeiServices
,
550 IN EFI_PEI_MP_SERVICES_PPI
*This
,
551 IN EFI_AP_PROCEDURE Procedure
,
552 IN UINTN ProcessorNumber
,
553 IN UINTN TimeoutInMicroseconds
,
554 IN VOID
*ProcedureArgument OPTIONAL
557 PEI_CPU_MP_DATA
*PeiCpuMpData
;
559 volatile UINT32
*FinishedCount
;
561 UINTN WaitCountIndex
;
562 UINTN WaitCountNumber
;
564 PeiCpuMpData
= GetMpHobData ();
565 if (PeiCpuMpData
== NULL
) {
566 return EFI_NOT_FOUND
;
570 // Check whether caller processor is BSP
572 PeiWhoAmI (PeiServices
, This
, &CallerNumber
);
573 if (CallerNumber
!= PeiCpuMpData
->BspNumber
) {
574 return EFI_DEVICE_ERROR
;
577 if (ProcessorNumber
>= PeiCpuMpData
->CpuCount
) {
578 return EFI_NOT_FOUND
;
581 if (ProcessorNumber
== PeiCpuMpData
->BspNumber
|| Procedure
== NULL
) {
582 return EFI_INVALID_PARAMETER
;
586 // Check whether specified AP is disabled
588 if (PeiCpuMpData
->CpuData
[ProcessorNumber
].State
== CpuStateDisabled
) {
589 return EFI_INVALID_PARAMETER
;
592 WaitCountNumber
= TimeoutInMicroseconds
/ CPU_CHECK_AP_INTERVAL
+ 1;
594 FinishedCount
= &PeiCpuMpData
->FinishedCount
;
596 WakeUpAP (PeiCpuMpData
, FALSE
, PeiCpuMpData
->CpuData
[ProcessorNumber
].ApicId
, Procedure
, ProcedureArgument
);
601 if (TimeoutInMicroseconds
== 0) {
602 while (*FinishedCount
< 1) {
605 Status
= EFI_SUCCESS
;
607 Status
= EFI_TIMEOUT
;
608 for (WaitCountIndex
= 0; WaitCountIndex
< WaitCountNumber
; WaitCountIndex
++) {
609 MicroSecondDelay (CPU_CHECK_AP_INTERVAL
);
610 if (*FinishedCount
>= 1) {
611 Status
= EFI_SUCCESS
;
622 This return the handle number for the calling processor. This service may be
623 called from the BSP and APs.
625 This service returns the processor handle number for the calling processor.
626 The returned value is in the range from 0 to the total number of logical
627 processors minus 1. The total number of logical processors can be retrieved
628 with EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors(). This service may be
629 called from the BSP and APs. If ProcessorNumber is NULL, then EFI_INVALID_PARAMETER
630 is returned. Otherwise, the current processors handle number is returned in
631 ProcessorNumber, and EFI_SUCCESS is returned.
633 @param[in] PeiServices An indirect pointer to the PEI Services Table
634 published by the PEI Foundation.
635 @param[in] This A pointer to the EFI_PEI_MP_SERVICES_PPI instance.
636 @param[out] ProcessorNumber The handle number of the AP. The range is from 0 to the
637 total number of logical processors minus 1. The total
638 number of logical processors can be retrieved by
639 EFI_PEI_MP_SERVICES_PPI.GetNumberOfProcessors().
641 @retval EFI_SUCCESS The current processor handle number was returned in
643 @retval EFI_INVALID_PARAMETER ProcessorNumber is NULL.
648 IN CONST EFI_PEI_SERVICES
**PeiServices
,
649 IN EFI_PEI_MP_SERVICES_PPI
*This
,
650 OUT UINTN
*ProcessorNumber
653 PEI_CPU_MP_DATA
*PeiCpuMpData
;
655 PeiCpuMpData
= GetMpHobData ();
656 if (PeiCpuMpData
== NULL
) {
657 return EFI_NOT_FOUND
;
660 if (ProcessorNumber
== NULL
) {
661 return EFI_INVALID_PARAMETER
;
664 return GetProcessorNumber (PeiCpuMpData
, ProcessorNumber
);