GitHub/qpcpp
1
0
Fork 0
mirror of https://github.com/QuantumLeaps/qpcpp.git synced 2025-01-28 06:02:56 +08:00
Code Issues Projects Releases Wiki Activity

5.7.4b

Browse Source
This commit is contained in:
Quantum Leaps 2016-11-08 12:48:44 -05:00
parent c06e502988
commit 38cca09ce3
14 changed files with 430 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -47,6 +47,7 @@ targetConfigs/
Debug/
Release/
Spy/
QSpy/
lib/
obj/

75
doxygen/metrics.dox
View File

@ -9,7 +9,7 @@
License Type: Windows Single User License
Licensed To : Quantum Leaps, LLC
License No. : WS2975 License Date: Dec 15, 2013
Build Date : Sep 2 2009 Run Date: Nov 01, 2016
Build Date : Sep 2 2009 Run Date: Nov 02, 2016
(C)1996-2009 M Squared Technologies LLC
________________________________________________________________________
@ -150,7 +150,7 @@
~~ Total File Summary ~~
LOC 254 eLOC 222 lLOC 130 Comment 311 Lines 651
LOC 255 eLOC 223 lLOC 131 Comment 311 Lines 652
------------------------------------------------------------------------
~~ File Functional Summary ~~
@ -826,8 +826,9 @@
Loops for / foreach : 1
Conditional if / else if: 5
Logical or ( || ) : 1
Complexity Param 1 Return 1 Cyclo Vg 13 Total 15
LOC 111 eLOC 98 lLOC 63 Comment 67 Lines 152
Logical and ( && ) : 1
Complexity Param 1 Return 1 Cyclo Vg 14 Total 16
LOC 112 eLOC 99 lLOC 63 Comment 68 Lines 154
Function: QP::QHsm::hsm_tran
Parameters: (QStateHandler (&path)[MAX_NEST_DEPTH_])
@ -860,27 +861,27 @@
~~ Total File Summary ~~
LOC 339 eLOC 292 lLOC 166 Comment 282 Lines 599
LOC 340 eLOC 293 lLOC 166 Comment 283 Lines 601
------------------------------------------------------------------------
~~ File Functional Summary ~~
File Function Count....: 7
Total Function LOC.....: 288 Total Function Pts LOC : 6.4
Total Function eLOC....: 244 Total Function Pts eLOC: 5.5
Total Function LOC.....: 289 Total Function Pts LOC : 6.4
Total Function eLOC....: 245 Total Function Pts eLOC: 5.5
Total Function lLOC....: 160 Total Function Pts lLOC: 3.1
Total Function Params .: 8 Total Function Return .: 7
Total Cyclo Complexity : 41 Total Function Complex.: 56
Total Cyclo Complexity : 42 Total Function Complex.: 57
------ ----- ----- ------ ------ -----
Max Function LOC ......: 111 Average Function LOC ..: 41.14
Max Function eLOC .....: 98 Average Function eLOC .: 34.86
Max Function LOC ......: 112 Average Function LOC ..: 41.29
Max Function eLOC .....: 99 Average Function eLOC .: 35.00
Max Function lLOC .....: 63 Average Function lLOC .: 22.86
------ ----- ----- ------ ------ -----
Max Function Parameters: 2 Avg Function Parameters: 1.14
Max Function Returns ..: 1 Avg Function Returns ..: 1.00
Max Interface Complex. : 3 Avg Interface Complex. : 2.14
Max Cyclomatic Complex.: 15 Avg Cyclomatic Complex.: 5.86
Max Total Complexity ..: 17 Avg Total Complexity ..: 8.00
Max Cyclomatic Complex.: 15 Avg Cyclomatic Complex.: 6.00
Max Total Complexity ..: 17 Avg Total Complexity ..: 8.14
________________________________________________________________________
End of File: ..\source\qep_hsm.cpp
@ -1002,12 +1003,12 @@
LOC 15 eLOC 14 lLOC 8 Comment 17 Lines 20
Function: QP::QF::remove_
Parameters: (QMActive const * const a)
Parameters: (QMActive * const a)
Cyclomatic Complexity Vg Detail
Function Base : 1
Logical and ( && ) : 2
Complexity Param 1 Return 1 Cyclo Vg 3 Total 5
LOC 15 eLOC 14 lLOC 8 Comment 17 Lines 20
LOC 16 eLOC 15 lLOC 9 Comment 18 Lines 21
Function: QP::QF::bzero
Parameters: (void * const start, uint_fast16_t len)
@ -1021,21 +1022,21 @@
~~ Total File Summary ~~
LOC 146 eLOC 140 lLOC 22 Comment 104 Lines 255
LOC 147 eLOC 141 lLOC 23 Comment 105 Lines 256
------------------------------------------------------------------------
~~ File Functional Summary ~~
File Function Count....: 3
Total Function LOC.....: 38 Total Function Pts LOC : 2.8
Total Function eLOC....: 34 Total Function Pts eLOC: 2.6
Total Function lLOC....: 20 Total Function Pts lLOC: 0.4
Total Function LOC.....: 39 Total Function Pts LOC : 2.8
Total Function eLOC....: 35 Total Function Pts eLOC: 2.7
Total Function lLOC....: 21 Total Function Pts lLOC: 0.4
Total Function Params .: 4 Total Function Return .: 3
Total Cyclo Complexity : 8 Total Function Complex.: 15
------ ----- ----- ------ ------ -----
Max Function LOC ......: 15 Average Function LOC ..: 12.67
Max Function eLOC .....: 14 Average Function eLOC .: 11.33
Max Function lLOC .....: 8 Average Function lLOC .: 6.67
Max Function LOC ......: 16 Average Function LOC ..: 13.00
Max Function eLOC .....: 15 Average Function eLOC .: 11.67
Max Function lLOC .....: 9 Average Function lLOC .: 7.00
------ ----- ----- ------ ------ -----
Max Function Parameters: 2 Avg Function Parameters: 1.33
Max Function Returns ..: 1 Avg Function Returns ..: 1.00
@ -2551,9 +2552,9 @@
~~ Total Project Summary ~~
LOC 5657 eLOC 4949 lLOC 2330 Comment 6658 Lines 12599
LOC 5660 eLOC 4952 lLOC 2332 Comment 6660 Lines 12603
Average per File, metric/41 files
LOC 137 eLOC 120 lLOC 56 Comment 162 Lines 307
LOC 138 eLOC 120 lLOC 56 Comment 162 Lines 307
------------------------------------------------------------------------
@ -2903,8 +2904,8 @@
Function: QP::QHsm::dispatch
Parameters: (QEvt const * const e)
Complexity Param 1 Return 1 Cyclo Vg 13 Total 15
LOC 111 eLOC 98 lLOC 63 Comment 67 Lines 152
Complexity Param 1 Return 1 Cyclo Vg 14 Total 16
LOC 112 eLOC 99 lLOC 63 Comment 68 Lines 154
Function: QP::QHsm::hsm_tran
Parameters: (QStateHandler (&path)[MAX_NEST_DEPTH_])
@ -2972,9 +2973,9 @@
LOC 15 eLOC 14 lLOC 8 Comment 17 Lines 20
Function: QP::QF::remove_
Parameters: (QMActive const * const a)
Parameters: (QMActive * const a)
Complexity Param 1 Return 1 Cyclo Vg 3 Total 5
LOC 15 eLOC 14 lLOC 8 Comment 17 Lines 20
LOC 16 eLOC 15 lLOC 9 Comment 18 Lines 21
Function: QP::QF::bzero
Parameters: (void * const start, uint_fast16_t len)
@ -3581,26 +3582,26 @@
LOC 14 eLOC 11 lLOC 7 Comment 2 Lines 16
Total: Functions
LOC 3492 eLOC 2895 lLOC 1769 InCmp 404 CycloCmp 573
LOC 3494 eLOC 2897 lLOC 1770 InCmp 404 CycloCmp 574
Function Points FP(LOC) 61.1 FP(eLOC) 51.2 FP(lLOC) 31.6
------------------------------------------------------------------------
~~ Project Functional Analysis ~~
Total Functions .......: 200 Total Physical Lines ..: 4517
Total LOC .............: 3492 Total Function Pts LOC : 61.1
Total eLOC ............: 2895 Total Function Pts eLOC: 51.2
Total lLOC.............: 1769 Total Function Pts lLOC: 31.6
Total Cyclomatic Comp. : 573 Total Interface Comp. .: 404
Total Functions .......: 200 Total Physical Lines ..: 4520
Total LOC .............: 3494 Total Function Pts LOC : 61.1
Total eLOC ............: 2897 Total Function Pts eLOC: 51.2
Total lLOC.............: 1770 Total Function Pts lLOC: 31.6
Total Cyclomatic Comp. : 574 Total Interface Comp. .: 404
Total Parameters ......: 204 Total Return Points ...: 200
Total Comment Lines ...: 2816 Total Blank Lines .....: 533
Total Comment Lines ...: 2818 Total Blank Lines .....: 533
------ ----- ----- ------ ------ -----
Avg Physical Lines ....: 22.59
Avg LOC ...............: 17.46 Avg eLOC ..............: 14.48
Avg Physical Lines ....: 22.60
Avg LOC ...............: 17.47 Avg eLOC ..............: 14.48
Avg lLOC ..............: 8.85 Avg Cyclomatic Comp. ..: 2.87
Avg Interface Comp. ...: 2.02 Avg Parameters ........: 1.02
Avg Return Points .....: 1.00 Avg Comment Lines .....: 14.08
Avg Return Points .....: 1.00 Avg Comment Lines .....: 14.09
------ ----- ----- ------ ------ -----
Max LOC ...............: 260
Max eLOC ..............: 202 Max lLOC ..............: 125

46
examples/arm-cm/dpp_efm32-slstk3401a/win32-qv/main.cpp
View File

@ -1,13 +1,13 @@
//****************************************************************************
// DPP example
// Last updated for version 5.6.0
// Last updated on 2015-12-26
// DPP example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, www.state-machine.com.
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
@ -28,24 +28,25 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Web: www.state-machine.com
// Email: info@state-machine.com
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "dpp.h"
#include "bsp.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *tableQueueSto[N_PHILO];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QP::QEvt const *tableQueueSto[N_PHILO*WIN_FUDGE_FACTOR];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO*WIN_FUDGE_FACTOR];
static QP::QSubscrList subscrSto[DPP::MAX_PUB_SIG];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO];
QP::QF::init(); // initialize the framework and the underlying RT kernel
DPP::BSP::init(); // initialize the BSP
// object dictionaries...
@ -76,3 +77,24 @@ int main() {
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

46
examples/arm-cm/dpp_efm32-slstk3401a/win32/main.cpp
View File

@ -1,13 +1,13 @@
//****************************************************************************
// DPP example
// Last updated for version 5.6.0
// Last updated on 2015-12-26
// DPP example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, www.state-machine.com.
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
@ -28,24 +28,25 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Web: www.state-machine.com
// Email: info@state-machine.com
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "dpp.h"
#include "bsp.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *tableQueueSto[N_PHILO];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QP::QEvt const *tableQueueSto[N_PHILO*WIN_FUDGE_FACTOR];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO*WIN_FUDGE_FACTOR];
static QP::QSubscrList subscrSto[DPP::MAX_PUB_SIG];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO];
QP::QF::init(); // initialize the framework and the underlying RT kernel
DPP::BSP::init(); // initialize the BSP
// object dictionaries...
@ -76,3 +77,24 @@ int main() {
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

113
examples/arm-cm/game_efm32-slstk3401a/win32-qv/main.cpp Normal file
View File

@ -0,0 +1,113 @@
//****************************************************************************
// Product: "Fly 'n' Shoot" game example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Alternatively, this program may be distributed and modified under the
// terms of Quantum Leaps commercial licenses, which expressly supersede
// the GNU General Public License and are specifically designed for
// licensees interested in retaining the proprietary status of their code.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "bsp.h"
#include "game.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *missileQueueSto[2*WIN_FUDGE_FACTOR];
static QP::QEvt const *shipQueueSto[3*WIN_FUDGE_FACTOR];
static QP::QEvt const *tunnelQueueSto[(GAME_MINES_MAX + 5)*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(QP::QEvt) smlPoolSto[10*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(GAME::ObjectImageEvt)
medPoolSto[(2*GAME_MINES_MAX + 10)*WIN_FUDGE_FACTOR];
static QP::QSubscrList subscrSto[GAME::MAX_PUB_SIG];
QP::QF::init(); // initialize the framework and the underlying RT kernel
GAME::BSP_init(); // initialize the Board Support Package
// initialize the event pools...
QP::QF::poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
QP::QF::poolInit(medPoolSto, sizeof(medPoolSto), sizeof(medPoolSto[0]));
// init publish-subscribe
QP::QF::psInit(subscrSto, Q_DIM(subscrSto));
// send object dictionaries for event queues...
QS_OBJ_DICTIONARY(missileQueueSto);
QS_OBJ_DICTIONARY(shipQueueSto);
QS_OBJ_DICTIONARY(tunnelQueueSto);
// send object dictionaries for event pools...
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(medPoolSto);
// send signal dictionaries for globally published events...
QS_SIG_DICTIONARY(GAME::TIME_TICK_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::PLAYER_TRIGGER_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::PLAYER_QUIT_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::GAME_OVER_SIG, static_cast<void *>(0));
// start the active objects...
GAME::AO_Tunnel ->start(1U, // priority
tunnelQueueSto, Q_DIM(tunnelQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
GAME::AO_Ship ->start(2U, // priority
shipQueueSto, Q_DIM(shipQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
GAME::AO_Missile->start(3U, // priority
missileQueueSto, Q_DIM(missileQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

113
examples/arm-cm/game_efm32-slstk3401a/win32/main.cpp Normal file
View File

@ -0,0 +1,113 @@
//****************************************************************************
// Product: "Fly 'n' Shoot" game example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Alternatively, this program may be distributed and modified under the
// terms of Quantum Leaps commercial licenses, which expressly supersede
// the GNU General Public License and are specifically designed for
// licensees interested in retaining the proprietary status of their code.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "bsp.h"
#include "game.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *missileQueueSto[2*WIN_FUDGE_FACTOR];
static QP::QEvt const *shipQueueSto[3*WIN_FUDGE_FACTOR];
static QP::QEvt const *tunnelQueueSto[(GAME_MINES_MAX + 5)*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(QP::QEvt) smlPoolSto[10*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(GAME::ObjectImageEvt)
medPoolSto[(2*GAME_MINES_MAX + 10)*WIN_FUDGE_FACTOR];
static QP::QSubscrList subscrSto[GAME::MAX_PUB_SIG];
QP::QF::init(); // initialize the framework and the underlying RT kernel
GAME::BSP_init(); // initialize the Board Support Package
// initialize the event pools...
QP::QF::poolInit(smlPoolSto, sizeof(smlPoolSto), sizeof(smlPoolSto[0]));
QP::QF::poolInit(medPoolSto, sizeof(medPoolSto), sizeof(medPoolSto[0]));
// init publish-subscribe
QP::QF::psInit(subscrSto, Q_DIM(subscrSto));
// send object dictionaries for event queues...
QS_OBJ_DICTIONARY(missileQueueSto);
QS_OBJ_DICTIONARY(shipQueueSto);
QS_OBJ_DICTIONARY(tunnelQueueSto);
// send object dictionaries for event pools...
QS_OBJ_DICTIONARY(smlPoolSto);
QS_OBJ_DICTIONARY(medPoolSto);
// send signal dictionaries for globally published events...
QS_SIG_DICTIONARY(GAME::TIME_TICK_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::PLAYER_TRIGGER_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::PLAYER_QUIT_SIG, static_cast<void *>(0));
QS_SIG_DICTIONARY(GAME::GAME_OVER_SIG, static_cast<void *>(0));
// start the active objects...
GAME::AO_Tunnel ->start(1U, // priority
tunnelQueueSto, Q_DIM(tunnelQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
GAME::AO_Ship ->start(2U, // priority
shipQueueSto, Q_DIM(shipQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
GAME::AO_Missile->start(3U, // priority
missileQueueSto, Q_DIM(missileQueueSto), // evt queue
static_cast<void *>(0), 0U); // no per-thread stack
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

44
examples/win32-qv/dpp/main.cpp
View File

@ -1,13 +1,13 @@
//****************************************************************************
// DPP example
// Last updated for version 5.4.0
// Last updated on 2015-04-29
// DPP example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, www.state-machine.com.
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
@ -28,20 +28,23 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Web: www.state-machine.com
// Email: info@state-machine.com
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "dpp.h"
#include "bsp.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *tableQueueSto[N_PHILO];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QP::QSubscrList subscrSto[DPP::MAX_PUB_SIG];
static QP::QEvt const *tableQueueSto[N_PHILO*WIN_FUDGE_FACTOR];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO];
static QP::QSubscrList subscrSto[DPP::MAX_PUB_SIG];
QP::QF::init(); // initialize the framework and the underlying RT kernel
@ -75,3 +78,24 @@ int main() {
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

46
examples/win32/dpp/main.cpp
View File

@ -1,13 +1,13 @@
//****************************************************************************
// DPP example
// Last updated for version 5.4.0
// Last updated on 2015-04-29
// DPP example for Windows
// Last updated for version 5.7.5
// Last updated on 2016-11-08
//
// Q u a n t u m L e a P s
// ---------------------------
// innovating embedded systems
//
// Copyright (C) Quantum Leaps, www.state-machine.com.
// Copyright (C) Quantum Leaps, LLC. All rights reserved.
//
// This program is open source software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as published
@ -28,24 +28,25 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Contact information:
// Web: www.state-machine.com
// Email: info@state-machine.com
// http://www.state-machine.com
// mailto:info@state-machine.com
//****************************************************************************
#include "qpcpp.h"
#include "dpp.h"
#include "bsp.h"
// "fudge factor" for Windows, see NOTE1
enum { WIN_FUDGE_FACTOR = 10 };
//............................................................................
int main() {
static QP::QEvt const *tableQueueSto[N_PHILO];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO];
static QP::QEvt const *tableQueueSto[N_PHILO*WIN_FUDGE_FACTOR];
static QP::QEvt const *philoQueueSto[N_PHILO][N_PHILO*WIN_FUDGE_FACTOR];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO*WIN_FUDGE_FACTOR];
static QP::QSubscrList subscrSto[DPP::MAX_PUB_SIG];
static QF_MPOOL_EL(DPP::TableEvt) smlPoolSto[2*N_PHILO];
QP::QF::init(); // initialize the framework and the underlying RT kernel
DPP::BSP_init(); // initialize the BSP
// object dictionaries...
@ -75,3 +76,24 @@ int main() {
return QP::QF::run(); // run the QF application
}
//****************************************************************************
// NOTE1:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous WIN_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//

BIN
ports/win32-qv/QSpy/vc120.pdb
View File

Binary file not shown.

21
ports/win32-qv/qf_port.cpp
View File

@ -2,14 +2,14 @@
/// \brief QF/C++ port to Win32 API with cooperative QV scheduler (win32-qv)
/// \cond
///***************************************************************************
/// Last updated for version 5.7.1
/// Last updated on 2016-09-23
/// Last updated for version 5.7.5
/// Last updated on 2016-11-08
///
/// Q u a n t u m L e a P s
/// ---------------------------
/// innovating embedded systems
///
/// Copyright (C) Quantum Leaps, www.state-machine.com.
/// Copyright (C) Quantum Leaps, LLC. All rights reserved.
///
/// This program is open source software: you can redistribute it and/or
/// modify it under the terms of the GNU General Public License as published
@ -155,18 +155,8 @@ void QMActive::start(uint_fast8_t prio,
m_prio = prio; // set the QF priority of this AO
QF::add_(this); // make QF aware of this AO
// ignore the original storage for the event queue 'qSto' and
// instead allocate an oversized "fudged" storage for the queue.
// See also NOTE2 in qf_port.h.
Q_ASSERT_ID(710, static_cast<uint32_t>(qLen) * QF_WIN32_FUDGE_FACTOR
< USHRT_MAX);
// fudged the queue length
uint_fast16_t fudgedQLen = qLen * QF_WIN32_FUDGE_FACTOR;
// fudged queue storage
void *fudgedQSto = new QEvt*[fudgedQLen];
// allocation must succeed
Q_ASSERT_ID(720, fudgedQSto != static_cast<void *>(0));
m_eQueue.init(static_cast<QEvt const **>(fudgedQSto), fudgedQLen);
m_eQueue.init(qSto, qLen);
this->init(ie); // execute initial transition (virtual call)
QS_FLUSH(); // flush the QS trace buffer to the host
@ -175,7 +165,6 @@ void QMActive::start(uint_fast8_t prio,
void QMActive::stop(void) {
unsubscribeAll();
QF::remove_(this);
delete[] m_eQueue.m_ring; // free the fudged queue storage
}
//****************************************************************************

41
ports/win32-qv/qf_port.h
View File

@ -2,8 +2,8 @@
/// \brief QF/C++ port to Win32 API with cooperative QV scheduler (win32-qv)
/// \cond
///***************************************************************************
/// Last updated for version 5.7.2
/// Last updated on 2016-09-28
/// Last updated for version 5.7.5
/// Last updated on 2016-11-08
///
/// Q u a n t u m L e a P s
/// ---------------------------
@ -67,8 +67,8 @@
#ifdef _MSC_VER // Microsoft C/C++ compiler?
// use built-in intrinsic function for fast LOG2
#define QF_LOG2(x_) ((uint_fast8_t)(32U - __lzcnt(x_)))
#include <intrin.h> /* VC++ intrinsic functions */
#define QF_LOG2(x_) (static_cast<uint_fast8_t>(32U - __lzcnt(x_)))
#include <intrin.h> // VC++ intrinsic functions
#elif __GNUC__ // GNU C/C++ compiler?
// use built-in intrinsic function for fast LOG2
#define QF_LOG2(x_) ((uint_fast8_t)(32U - __builtin_clz(x_)))
@ -163,13 +163,8 @@ void QF_onClockTick(void);
// Win32-QV specific event pool operations
#define QF_EPOOL_TYPE_ QMPool
#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) do { \
uint_fast32_t fudgedSize = (poolSize_) * QF_WIN32_FUDGE_FACTOR; \
uint8_t *fudgedSto = new uint8_t[(poolSize_)*QF_WIN32_FUDGE_FACTOR]; \
Q_ASSERT_ID(210, fudgedSto != (uint8_t *)0); \
(void)(poolSto_); \
(p_).init(fudgedSto, fudgedSize, evtSize_); \
} while (false)
#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
(p_).init((poolSto_), (poolSize_), (evtSize_))
#define QF_EPOOL_EVENT_SIZE_(p_) ((p_).getBlockSize())
#define QF_EPOOL_GET_(p_, e_, m_) \
@ -182,11 +177,6 @@ void QF_onClockTick(void);
namespace QP {
extern QPSet QV_readySet_; // QV-ready set of active objects
extern HANDLE QV_win32Event_; // Win32 event to signal events
// Windows "fudge factor" for oversizing the resources, see NOTE2
enum {
QF_WIN32_FUDGE_FACTOR = 100
};
} // namespace QP
#endif // QP_IMPL
@ -225,24 +215,5 @@ void QF_onClockTick(void);
// Scheduler locking (used inside QF_publish_()) is not needed in the single-
// threaded Win32-QV port, because event multicasting is already atomic.
//
// NOTE3:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous QF_WIN32_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//
#endif // qf_port_h

BIN
ports/win32/QSpy/vc120.pdb
View File

Binary file not shown.

33
ports/win32/qf_port.cpp
View File

@ -2,14 +2,14 @@
/// \brief QF/C++ port to Win32 API
/// \cond
///***************************************************************************
/// Last updated for version 5.6.2
/// Last updated on 2016-01-22
/// Last updated for version 5.7.5
/// Last updated on 2016-11-08
///
/// Q u a n t u m L e a P s
/// ---------------------------
/// innovating embedded systems
///
/// Copyright (C) Quantum Leaps, www.state-machine.com.
/// Copyright (C) Quantum Leaps, LLC. All rights reserved.
///
/// This program is open source software: you can redistribute it and/or
/// modify it under the terms of the GNU General Public License as published
@ -94,7 +94,6 @@ void QF::thread_(QMActive *act) {
act->unsubscribeAll(); // make sure that no events are subscribed
QF::remove_(act); // remove this object from any subscriptions
CloseHandle(act->m_osObject); // cleanup the OS event
delete[] act->m_eQueue.m_ring; // free the fudged queue storage
}
//****************************************************************************
// helper function to match the signature expeced by CreateThread() Win32 API
@ -122,7 +121,6 @@ int_t QF::run(void) {
onCleanup(); // cleanup callback
QS_EXIT(); // cleanup the QSPY connection
//DeleteCriticalSection(&l_win32CritSect);
//free all "fudged" event pools...
return static_cast<int_t>(0); // return success
}
//****************************************************************************
@ -154,25 +152,14 @@ void QMActive::start(uint_fast8_t prio,
m_prio = prio; // set the QF priority of this AO
QF::add_(this); // make QF aware of this AO
// ignore the original storage for the event queue 'qSto' and
// instead allocate an oversized "fudged" storage for the queue.
// See also NOTE2 in qf_port.h.
//
Q_ASSERT_ID(710, static_cast<uint32_t>(qLen) * QF_WIN32_FUDGE_FACTOR
< USHRT_MAX);
// fudge the queue length
uint_fast16_t fudgedQLen = qLen * QF_WIN32_FUDGE_FACTOR;
QEvt const **fudgedQSto = new QEvt const *[fudgedQLen]; // fudged queue storage
// allocation must succeed
Q_ASSERT_ID(720, fudgedQSto != static_cast<QEvt const * *>(0));
m_eQueue.init(fudgedQSto, fudgedQLen);
m_eQueue.init(qSto, qLen);
// save osObject as integer, in case it contains the Win32 priority
int win32Prio = (m_osObject != static_cast<void *>(0))
? reinterpret_cast<int>(m_osObject)
: THREAD_PRIORITY_NORMAL;
/* create the Win32 "event" to throttle the AO's event queue */
// create the Win32 "event" to throttle the AO's event queue
m_osObject = CreateEvent(NULL, FALSE, FALSE, NULL);
this->init(ie); // execute initial transition (virtual call)
@ -182,11 +169,17 @@ void QMActive::start(uint_fast8_t prio,
if (stkSize == 0U) {
stkSize = 1024U; // NOTE: will be rounded up to the nearest page
}
m_thread = CreateThread(NULL, stkSize, &ao_thread, this, 0, NULL);
Q_ASSERT_ID(730, m_thread != NULL); // thread must be created
// create a Win32 thread for the AO;
// The thread is created with THREAD_PRIORITY_NORMAL
m_thread = CreateThread(NULL, stkSize, &ao_thread, this, 0, NULL);
Q_ASSERT_ID(730, m_thread != static_cast<HANDLE>(0)); // must succeed
// was the thread priority provided?
if (win32Prio != 0) {
SetThreadPriority(m_thread, win32Prio);
}
}
//****************************************************************************
void QMActive::stop(void) {
m_thread = static_cast<HANDLE>(0); // stop the QActive::run() loop

39
ports/win32/qf_port.h
View File

@ -2,8 +2,8 @@
/// \brief QF/C++ port to Win32 API
/// \cond
///***************************************************************************
/// Last updated for version 5.7.2
/// Last updated on 2016-09-28
/// Last updated for version 5.7.5
/// Last updated on 2016-11-08
///
/// Q u a n t u m L e a P s
/// ---------------------------
@ -172,13 +172,8 @@ void QF_onClockTick(void);
// Win32-specific event pool operations
#define QF_EPOOL_TYPE_ QMPool
#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) do { \
uint_fast32_t fudgedSize = (poolSize_) * QF_WIN32_FUDGE_FACTOR; \
uint8_t *fudgedSto = new uint8_t[(poolSize_)*QF_WIN32_FUDGE_FACTOR]; \
Q_ASSERT_ID(210, fudgedSto != (uint8_t *)0); \
(void)(poolSto_); \
(p_).init(fudgedSto, fudgedSize, evtSize_); \
} while (false)
#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_) \
(p_).init((poolSto_), (poolSize_), (evtSize_))
#define QF_EPOOL_EVENT_SIZE_(p_) ((p_).getBlockSize())
#define QF_EPOOL_GET_(p_, e_, m_) \
@ -188,13 +183,6 @@ void QF_onClockTick(void);
#define WIN32_LEAN_AND_MEAN
#include <windows.h> // Win32 API
namespace QP {
// Windows "fudge factor" for oversizing the resources, see NOTE2
enum {
QF_WIN32_FUDGE_FACTOR = 100
};
} // namespace QP
#endif // QP_IMPL
// NOTES: ====================================================================
@ -233,24 +221,5 @@ void QF_onClockTick(void);
// will appear atomic, in the sense that no thread will be able to post
// events during multicasting.
//
// NOTE3:
// Windows is not a deterministic real-time system, which means that the
// system can occasionally and unexpectedly "choke and freeze" for a number
// of seconds. The designers of Windows have dealt with these sort of issues
// by massively oversizing the resources available to the applications. For
// example, the default Windows GUI message queues size is 10,000 entries,
// which can dynamically grow to an even larger number. Also the stacks of
// Win32 threads can dynamically grow to several megabytes.
//
// In contrast, the event queues, event pools, and stack size inside the
// real-time embedded (RTE) systems can be (and must be) much smaller,
// because you typically can put an upper bound on the real-time behavior
// and the resulting delays.
//
// To be able to run the unmodified applications designed originally for
// RTE systems on Windows, and to reduce the odds of resource shortages in
// this case, the generous QF_WIN32_FUDGE_FACTOR is used to oversize the
// event queues and event pools.
//
#endif // qf_port_h