1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
|
/*
* INTEL CONFIDENTIAL
* Copyright © 2011 Intel
* Corporation All Rights Reserved.
*
* The source code contained or described herein and all documents related to
* the source code ("Material") are owned by Intel Corporation or its suppliers
* or licensors. Title to the Material remains with Intel Corporation or its
* suppliers and licensors. The Material contains trade secrets and proprietary
* and confidential information of Intel or its suppliers and licensors. The
* Material is protected by worldwide copyright and trade secret laws and
* treaty provisions. No part of the Material may be used, copied, reproduced,
* modified, published, uploaded, posted, transmitted, distributed, or
* disclosed in any way without Intel’s prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Intel in writing.
*
* CREATED: 2011-06-01
* UPDATED: 2011-07-27
*/
#pragma once
#include <pthread.h>
#include <map>
#include <vector>
#include <list>
#include "RemoteCommandHandlerTemplate.h"
#include "PathNavigator.h"
#include "SelectionCriterionType.h"
#include "SelectionCriterion.h"
#include "Element.h"
#include "XmlDocSink.h"
#include "XmlDocSource.h"
class CElementLibrarySet;
class CSubsystemLibrary;
class CSystemClass;
class CSelectionCriteria;
class CParameterFrameworkConfiguration;
class CSystemClassConfiguration;
class CParameterBlackboard;
class CConfigurableDomains;
class IRemoteProcessorServerInterface;
class CBackSynchronizer;
class CParameterHandle;
class CSubsystemPlugins;
class CParameterAccessContext;
class CConfigurableElement;
class CParameterMgr : private CElement
{
enum ChildElement {
EFrameworkConfiguration,
ESelectionCriteria,
ESystemClass,
EConfigurableDomains
};
enum ElementLibrary {
EFrameworkConfigurationLibrary,
EParameterCreationLibrary,
EParameterConfigurationLibrary
};
// Remote command parsers
typedef TRemoteCommandHandlerTemplate<CParameterMgr> CCommandHandler;
typedef CCommandHandler::CommandStatus (CParameterMgr::*RemoteCommandParser)(const IRemoteCommand& remoteCommand, string& strResult);
// Parser descriptions
struct SRemoteCommandParserItem
{
const char* _pcCommandName;
CParameterMgr::RemoteCommandParser _pfnParser;
uint32_t _uiMinArgumentCount;
const char* _pcHelp;
const char* _pcDescription;
};
// Version
static const uint32_t guiEditionMajor = 0x2;
static const uint32_t guiEditionMinor = 0x2;
static const uint32_t guiRevision = 0x0;
// Parameter handle friendship
friend class CParameterHandle;
public:
// Logger interface
class ILogger
{
public:
virtual void log(bool bIsWarning, const std::string& strLog) = 0;
protected:
virtual ~ILogger() {}
};
// Construction
CParameterMgr(const string& strConfigurationFilePath);
virtual ~CParameterMgr();
// Logging
void setLogger(ILogger* pLogger);
// Init
bool load(string& strError);
virtual bool init(string& strError);
// Selection Criteria
CSelectionCriterionType* createSelectionCriterionType(bool bIsInclusive);
CSelectionCriterion* createSelectionCriterion(const string& strName, const CSelectionCriterionType* pSelectionCriterionType);
// Selection criterion retrieval
CSelectionCriterion* getSelectionCriterion(const string& strName);
// Configuration application
void applyConfigurations();
/**
* Returns the CConfigurableElement corresponding to the path given in argument.
*
* @param[in] strPath A string representing a path to an element.
* @param[out] strError Error message
*
* @return A const pointer to the corresponding CConfigurableElement.
* On error, NULL is returned and the error is explained in strError.
*/
const CConfigurableElement* getConfigurableElement(const string& strPath,
string& strError) const;
// Dynamic parameter handling
CParameterHandle* createParameterHandle(const string& strPath, string& strError);
//////////// Tuning /////////////
// Tuning mode
bool setTuningMode(bool bOn, string& strError);
bool tuningModeOn() const;
// Current value space for user set/get value interpretation
void setValueSpace(bool bIsRaw);
bool valueSpaceIsRaw();
// Current Output Raw Format for user get value interpretation
void setOutputRawFormat(bool bIsHex);
bool outputRawFormatIsHex();
// Automatic hardware synchronization control (during tuning session)
bool setAutoSync(bool bAutoSyncOn, string& strError);
bool autoSyncOn() const;
bool sync(string& strError);
// User set/get parameters
bool accessValue(CParameterAccessContext& parameterAccessContext, const string& strPath, string& strValue, bool bSet, string& strError);
bool accessParameterValue(const string& strPath, string& strValue, bool bSet, string& strError);
/**
* Returns the element mapping corresponding to the path given in parameter.
*
* @param[in] strPath Path of an element
* @param[out] strValue A sting containing the mapping
*
* @return true if a mapping was found for this element
*/
bool getParameterMapping(const string& strPath, string& strValue) const;
bool accessConfigurationValue(const string &strDomain, const string &stConfiguration, const string& strPath, string& strValue, bool bSet, string& strError);
////////// Configuration/Domains handling //////////////
// Creation/Deletion
bool createDomain(const string& strName, string& strError);
bool deleteDomain(const string& strName, string& strError);
bool deleteAllDomains(string& strError);
bool createConfiguration(const string& strDomain, const string& strConfiguration, string& strError);
bool deleteConfiguration(const string& strDomain, const string& strConfiguration, string& strError);
// Save/Restore
bool restoreConfiguration(const string& strDomain, const string& strConfiguration, list<string>& strError);
bool saveConfiguration(const string& strDomain, const string& strConfiguration, string& strError);
// Configurable element - domain association
bool addConfigurableElementToDomain(const string& strDomain, const string& strConfigurableElementPath, string& strError);
bool removeConfigurableElementFromDomain(const string& strDomain, const string& strConfigurableElementPath, string& strError);
bool split(const string& strDomain, const string& strConfigurableElementPath, string& strError);
/**
* Method that imports Configurable Domains from an Xml source.
*
* @param[in] strXmlSource a string containing an xml description or a path to an xml file
* @param[in] bWithSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] bFromFile a boolean that determines if the source is an xml description in
* strXmlSource or contained in a file. In that case strXmlSource is just the file path.
* @param[out] strError is used as the error output
*
* @return false if any error occures
*/
bool importDomainsXml(const string& strXmlSource, bool bWithSettings, bool bFromFile,
string& strError);
/**
* Method that exports Configurable Domains to an Xml destination.
* If bToFile is false, the xml description from the xml document will be written
* in strXmlDest. Otherwise it will be written in a file located at the path in strXmlDest
*
* @param[in:out] strXmlDest a string containing an xml description or a path to an xml file
* @param[in] bWithSettings a boolean that determines if the settings should be used in the
* xml description
* @param[in] bToFile a boolean that determines if the destination is an xml description in
* strXmlDest or contained in a file. In that case strXmlDest is just the file path.
* @param[out] strError is used as the error output
*
* @return false if any error occures
*/
bool exportDomainsXml(string& strXmlDest, bool bWithSettings, bool bToFile,
string& strError) const;
// Binary Import/Export
bool importDomainsBinary(const string& strFileName, string& strError);
bool exportDomainsBinary(const string& strFileName, string& strError);
/**
* Method that creates an Xml description of the instanciated parameter structure contained
* in SystemClass.
*
* @param[out] strResult contains the xml description of SystemClass or the errors if any
*
* @return false if any error occures during the creation of the xml description
*/
bool getSystemClassXMLString(string& strResult);
// Introspect
void logStructureContent(string& strContent) const;
// CElement
virtual string getKind() const;
private:
CParameterMgr(const CParameterMgr&);
CParameterMgr& operator=(const CParameterMgr&);
// Logging (done by root)
virtual void doLog(bool bIsWarning, const string& strLog) const;
virtual void nestLog() const;
virtual void unnestLog() const;
// Version
string getVersion() const;
////////////////:: Remote command parsers
/// Version
CCommandHandler::CommandStatus versionCommandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Status
CCommandHandler::CommandStatus statusCommandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Tuning Mode
CCommandHandler::CommandStatus setTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Value Space
CCommandHandler::CommandStatus setValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Output Raw Format
CCommandHandler::CommandStatus setOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Sync
CCommandHandler::CommandStatus setAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus syncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Criteria
CCommandHandler::CommandStatus listCriteriaCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Domains
CCommandHandler::CommandStatus listDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus createDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus deleteDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus deleteAllDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus renameDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus setSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listDomainElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus addElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus removeElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus splitDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Configurations
CCommandHandler::CommandStatus listConfigurationsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus dumpDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus createConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus deleteConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus renameConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus saveConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus restoreConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus setElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus setRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus clearRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Elements/Parameters
CCommandHandler::CommandStatus listElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listParametersCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus dumpElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getElementSizeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus showPropertiesCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus setParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus getConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus setConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listBelongingDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listAssociatedDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus showMappingCommmandProcess(const IRemoteCommand& remoteCommand,
string& strResult);
/// Browse
CCommandHandler::CommandStatus listAssociatedElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listConflictingElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus listRogueElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/// Settings Import/Export
CCommandHandler::CommandStatus exportConfigurableDomainsToXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus importConfigurableDomainsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus exportConfigurableDomainsWithSettingsToXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus importConfigurableDomainsWithSettingsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus exportSettingsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
CCommandHandler::CommandStatus importSettingsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult);
/**
* Command handler method for getConfigurableDomainWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus getConfigurableDomainsWithSettingsXMLCommmandProcess(
const IRemoteCommand& remoteCommand, string& strResult);
/**
* Command handler method for setConfigurableDomainWithSettings command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus setConfigurableDomainsWithSettingsXMLCommmandProcess(
const IRemoteCommand& remoteCommand, string& strResult);
/**
* Command handler method for getSystemClass command.
*
* @param[in] remoteCommand contains the arguments of the received command.
* @param[out] strResult a string containing the result of the command
*
* @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed
* in the other case
*/
CCommandHandler::CommandStatus getSystemClassXMLCommmandProcess(
const IRemoteCommand& remoteCommand, string& strResult);
// Max command usage length, use for formatting
void setMaxCommandUsageLength();
// For tuning, check we're in tuning mode
bool checkTuningModeOn(string& strError) const;
// Blackboard (dynamic parameter handling)
pthread_mutex_t* getBlackboardMutex();
// Blackboard reference (dynamic parameter handling)
CParameterBlackboard* getParameterBlackboard();
// Parameter access
bool doSetValue(const string& strPath, const string& strValue, bool bRawValueSpace, bool bDynamicAccess, string& strError) const;
bool doGetValue(const string& strPath, string& strValue, bool bRawValueSpace, bool bHexOutputRawFormat, bool bDynamicAccess, string& strError) const;
// Framework global configuration loading
bool loadFrameworkConfiguration(string& strError);
// System class Structure loading
bool loadStructure(string& strError);
// System class Structure loading
bool loadSettings(string& strError);
// Parse XML file into Root element
bool xmlParse(CXmlElementSerializingContext& elementSerializingContext, CElement* pRootElement, const string& strXmlFilePath, const string& strXmlFolder, ElementLibrary eElementLibrary, const string& strNameAttrituteName = "Name");
// Framework Configuration
CParameterFrameworkConfiguration* getFrameworkConfiguration();
const CParameterFrameworkConfiguration* getConstFrameworkConfiguration();
// Selection Criteria
CSelectionCriteria* getSelectionCriteria();
const CSelectionCriteria* getConstSelectionCriteria();
// System Class
CSystemClass* getSystemClass();
const CSystemClass* getConstSystemClass() const;
// Configurable Domains
CConfigurableDomains* getConfigurableDomains();
const CConfigurableDomains* getConstConfigurableDomains();
const CConfigurableDomains* getConstConfigurableDomains() const;
// Apply configurations
void doApplyConfigurations(bool bForce);
// Dynamic object creation libraries feeding
void feedElementLibraries();
// Remote Processor Server connection handling
bool handleRemoteProcessingInterface(string& strError);
// Back synchronization
CBackSynchronizer* createBackSynchronizer() const;
// Tuning
bool _bTuningModeIsOn;
// Value Space
bool _bValueSpaceIsRaw;
// Output Raw Format
bool _bOutputRawFormatIsHex;
// Automatic synchronization to HW during Tuning session
bool _bAutoSyncOn;
// Current Parameter Settings
CParameterBlackboard* _pMainParameterBlackboard;
// Dynamic object creation
CElementLibrarySet* _pElementLibrarySet;
// XML parsing, object creation handling
string _strXmlConfigurationFilePath; // Configuration file path
string _strXmlConfigurationFolderPath; // Root folder for configuration file
string _strSchemaFolderLocation; // Place where schemas stand
// Subsystem plugin location
const CSubsystemPlugins* _pSubsystemPlugins;
// Whole system structure checksum
uint8_t _uiStructureChecksum;
// Command Handler
CCommandHandler* _pCommandHandler;
// Remote Processor Server
IRemoteProcessorServerInterface* _pRemoteProcessorServer;
// Parser description array
static const SRemoteCommandParserItem gastRemoteCommandParserItems[];
// Parser description array size
static const uint32_t guiNbRemoteCommandParserItems;
// Maximum command usage length
uint32_t _uiMaxCommandUsageLength;
// Blackboard access mutex
pthread_mutex_t _blackboardMutex;
// Logging
ILogger* _pLogger;
mutable uint32_t _uiLogDepth;
};
|