OpenASIP 2.2
Loading...
Searching...
No Matches
MinimizeMachine.cc
Go to the documentation of this file.
1/*
2 Copyright (c) 2002-2011 Tampere University.
3
4 This file is part of TTA-Based Codesign Environment (TCE).
5
6 Permission is hereby granted, free of charge, to any person obtaining a
7 copy of this software and associated documentation files (the "Software"),
8 to deal in the Software without restriction, including without limitation
9 the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 and/or sell copies of the Software, and to permit persons to whom the
11 Software is furnished to do so, subject to the following conditions:
12
13 The above copyright notice and this permission notice shall be included in
14 all copies or substantial portions of the Software.
15
16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 DEALINGS IN THE SOFTWARE.
23 */
24/**
25 * @file MinimizeMachine.cc
26 *
27 * Explorer plugin that removes resources until the real time requirements
28 * of applications are not reached anymore.
29 *
30 * @author Jari Mäntyneva 2007 (jari.mantyneva-no.spam-tut.fi)
31 * @author Esa Määttä 2008 (esa.maatta-no.spam-tut.fi)
32 * @author Pekka Jääskeläinen 2011
33 * @note rating: red
34 */
35
36#include <vector>
37#include <set>
38#include <string>
39
41
42#include "DSDBManager.hh"
43#include "Machine.hh"
44
47#include "CostEstimates.hh"
48#include "SimulatorConstants.hh"
49#include "Conversion.hh"
50#include "ObjectState.hh"
51
52using namespace TTAProgram;
53using namespace TTAMachine;
54using namespace HDB;
55
56/**
57 * Explorer plugin that removes resources until the real time requirements
58 * of applications are not reached anymore.
59 *
60 * @TODO: maxRunTime parameter, which overrides app dir max runtime setting
61 * @TODO: if no maxRunTime then no frequency is needed == no cycle count
62 * limits
63 *
64 * Supported parameters:
65 * - min_bus, boolean for do minimize busses minimization, default true.
66 * - min_fu, boolean for do minimize FUs minimization, default true.
67 * - min_rf, boolean for do minimize RFs minimization, default true.
68 * - frequency, running frequency for applications.
69 */
71 PLUGIN_DESCRIPTION("Removes resources until the real time "
72 "requirements of applications are not reached anymore.");
73
75 minBus_(true),
76 minFU_(true),
77 minRF_(true),
78 frequency_(0) {
79
80 // compulsory parameters
82
83 // parameters that have a default value
87 }
88
89 virtual bool requiresStartingPointArchitecture() const { return true; }
90 virtual bool producesArchitecture() const { return true; }
91 virtual bool requiresHDB() const { return true; }
92 virtual bool requiresSimulationData() const { return false; }
93
94 /**
95 * Minimizes given configuration by not exceeding applications max
96 * runtime which depends on given frequncy
97 */
98 virtual std::vector<RowID>
99 explore(const RowID& configurationID, const unsigned int&) {
100 std::vector<RowID> result;
101
103
104 // TODO: make better parameter error function
105 if (frequency_ < 1) {
106 result.push_back(configurationID);
107 return result;
108 }
109
110 RowID min = minimizeMachine(configurationID);
111
112 result.push_back(min);
113 return result;
114 }
115
116private:
117 // parameter name variables
118 static const std::string minBusPN_;
119 static const std::string minFUPN_;
120 static const std::string minRFPN_;
121 static const std::string frequencyPN_;
122
123 /// minimize busses
125 /// minimize function units
126 bool minFU_;
127 /// minimize register files
128 bool minRF_;
129 /// running frequency in MHz for apps
130 unsigned int frequency_;
131
132 /**
133 * Reads the parameters given to the plugin.
134 */
142
143
144 /**
145 * Minimizes the number of buses, function units and register files in the given
146 * configuration in that order.
147 *
148 * This function minimizes the buses first, then function units and then
149 * register files.
150 * Removes also the extra sockets after minimization. Won't handle
151 * implementaions (IDF handling missing from fu and rf part).
152 *
153 * @param confToMinimize Configuration to be minimized.
154 * @param maxCycles Maximum clock cycle count that won't be exceeded.
155 * @return Minimized configuration id.
156 */
157 RowID minimizeMachine(RowID confToMinimize) {
158
159 // calculate maxCycleCounts for all apps
160 DSDBManager& dsdb = db();
161 std::vector<ClockCycleCount> maxCycleCounts;
162 std::set<RowID> applicationIDs = dsdb.applicationIDs();
163 std::set<RowID>::const_iterator applicationIter;
164 for (applicationIter = applicationIDs.begin();
165 applicationIter != applicationIDs.end();
166 applicationIter++) {
167
168 TestApplication testApplication(
169 dsdb.applicationPath(*applicationIter));
170
171 if (testApplication.maxRuntime() <= 0) {
172 maxCycleCounts.push_back(0);
173 } else {
174 maxCycleCounts.push_back(
175 static_cast<ClockCycleCount>(
176 testApplication.maxRuntime() *
177 static_cast<double>(frequency_) *
178 static_cast<double>(1000000)));
179 }
180 }
181
182 RowID orgConfToMinimize = confToMinimize;
183 if (minBus_) {
184 confToMinimize = minimizeBuses(confToMinimize, maxCycleCounts);
185 CostEstimates res;
186 evaluate(dsdb.configuration(confToMinimize), res, true);
187 }
188
189 if (minFU_) {
190 confToMinimize = minimizeFunctionUnits(
191 confToMinimize,
192 maxCycleCounts);
193 CostEstimates res;
194 evaluate(dsdb.configuration(confToMinimize), res, true);
195 }
196
197 if (minRF_) {
198 confToMinimize = minimizeRegisterFiles(
199 confToMinimize,
200 maxCycleCounts);
201 CostEstimates res;
202 evaluate(dsdb.configuration(confToMinimize), res, true);
203 }
204
205 if (orgConfToMinimize == confToMinimize) {
206 debugLog(
207 std::string("No new config could be generated by "
208 "MinimizeMachine plugin."));
209 }
210 CostEstimates res;
211 evaluate(dsdb.configuration(confToMinimize), res, true);
212 return confToMinimize;
213 }
214
215 /**
216 * Reduces the number of buses in the machine as much as possible to still
217 * achieve the application run time requirements.
218 *
219 * This function can handle implementations. Uses binary search to minimize
220 * the buses.
221 *
222 * @param confToMinimize ID of the machine configuration which buses
223 * are reduced.
224 * @param maxCycleCounts Max cycle counts per program.
225 * @return ID of the new congiguration where buses are reduced.
226 */
227 RowID
229 RowID confToMinimize,
230 std::vector<ClockCycleCount>& maxCycleCounts) {
231
232 DSDBManager& dsdb = db();
233
235 dsdb.configuration(confToMinimize);
236
237 TTAMachine::Machine* mach = NULL;
238 try {
239 mach = dsdb.architecture(configuration.architectureID);
240 } catch (const Exception& e) {
241 debugLog(std::string("No machine architecture found in config id "
242 "by MimimizeMachine plugin. "));
243 delete mach;
244 return confToMinimize;
245 }
246
248
249 // can't reduce buses from one
250 int origBusCount = busNav.count();
251 if (origBusCount < 2) {
252 return confToMinimize;
253 }
254
255 DesignSpaceExplorer explorer;
256 explorer.setDSDB(dsdb);
257
258 CostEstimates estimates;
259
260 // new configuration must be created
262 startConf.architectureID = dsdb.addArchitecture(*mach);
263 startConf.hasImplementation = false;
264
265 if (!explorer.evaluate(startConf, estimates, false)) {
266 delete mach;
267 mach = NULL;
268 // return the original conf
269 return confToMinimize;
270 }
271
272 // check if some apps maxCycles was exceeded
273 if (!checkCycleCounts(startConf, maxCycleCounts)) {
274 delete mach;
275 mach = NULL;
276 // return the original conf
277 return confToMinimize;
278 }
279
281
282 // variables for binary search
283 int busHigh = origBusCount;
284 int busLow = 1;
285 int busMid = (busLow + busHigh) /2;
286
287 TTAMachine::Machine* newMach = NULL;
288 RowID lastArchID = 0;
289 RowID lastConfID = 0;
290 RowID lastOKArchID = 0;
291 RowID lastOKConfID = 0;
292
293 std::list<std::string> removedBusNames;
294
295 // use binary search to find out the bus count that can be removed
296 // removes busses as long as each apps max cycle counts are not exceeded
297 // if buses are not of equal value this doesn't really work.
298 do {
299 assert(newMach == NULL);
300 newMach = new TTAMachine::Machine(*mach);
301
302 int busesToRemove = (origBusCount - busMid);
303
304 if (!modifier.removeBuses(busesToRemove, *newMach, removedBusNames)) {
305 // TODO: some good way to cope with non complete bus removal
306 }
307
308 DSDBManager::MachineConfiguration newConfiguration;
309 try {
310 lastArchID = dsdb.addArchitecture(*newMach);
311 // machine stored to dsdb can be deleted
312 delete newMach;
313 newMach = NULL;
314 } catch (const RelationalDBException& e) {
315 // Error occurred while adding adf to the dsdb, adf
316 // probably too big
317 delete newMach;
318 newMach = NULL;
319 break;
320 }
321
322 newConfiguration.architectureID = lastArchID;
323 newConfiguration.hasImplementation = false;
324 try {
325 lastConfID = dsdb.addConfiguration(newConfiguration);
326 } catch (const KeyNotFound& e) {
327 break;
328 }
329 CostEstimates newEstimates;
330
331 bool newConfigOK = false;
332 if (explorer.evaluate(newConfiguration, newEstimates, false)) {
333 // goes through every apps new cycles
334 newConfigOK =
335 checkCycleCounts(newConfiguration, maxCycleCounts);
336 }
337
338 if (newConfigOK) {
339 busHigh = busMid - 1;
340 busMid = (busLow + busMid) / 2;
341 lastOKArchID = lastArchID;
342 lastOKConfID = lastConfID;
343 } else {
344 busLow = busMid + 1;
345 busMid = (busMid + busHigh) / 2;
346 }
347 } while (busLow <= busHigh && busLow <= busMid);
348
349 // these aren't needed anymore
350 lastArchID = 0;
351 lastConfID = 0;
352
353 // delete old machine
354 delete mach;
355 mach = NULL;
356
357 // check if no new architecture/config could be created
358 if (lastOKArchID == 0) {
359 return confToMinimize;
360 }
361
362 // create new idf for the new machine if needed
363 if (configuration.hasImplementation) {
365 dsdb.implementation(configuration.implementationID);
366
367 // remove removed busses from orginal implementation file
368 std::list<std::string>::const_iterator busNameIter =
369 removedBusNames.begin();
370 while (busNameIter != removedBusNames.end()) {
371 idf->removeBusImplementation(*busNameIter);
372 busNameIter++;
373 }
374
375 DSDBManager::MachineConfiguration newConfiguration;
376 newConfiguration.architectureID = lastOKArchID;
377
378 CostEstimates newEstimates;
379 if (explorer.evaluate(newConfiguration, newEstimates, false)) {
380 newConfiguration.implementationID =
382 *idf, newEstimates.longestPathDelay(),newEstimates.area());
383
384 delete idf;
385 idf = NULL;
386
387 newConfiguration.hasImplementation = true;
388 // add new configuration
389 RowID confID = dsdb.addConfiguration(newConfiguration);
390 return confID;
391 } else {
392 return confToMinimize;
393 }
394 } else {
395 return lastOKConfID;
396 }
397
398 assert(false);
399 return 9999;
400 }
401
402 /**
403 * Reduces the number of register files in the machine as much as possible
404 * to still achieve the application run time requirements.
405 *
406 * This function won't handle implementations.
407 *
408 * @param confToMinimize ID of the machine configuration which register
409 * files are reduced.
410 * @param maxCycleCounts Max cycle counts per program.
411 * @return ID of the new congiguration where register files are reduced or
412 * same that was given if nothing was done.
413 */
415 RowID confToMinimize,
416 std::vector<ClockCycleCount>& maxCycleCounts) {
417
418 DSDBManager& dsdb = db();
419 RowID latestConfID = 0;
420
422 DesignSpaceExplorer explorer;
423 explorer.setDSDB(dsdb);
424
426 dsdb.configuration(confToMinimize);
427
428 const TTAMachine::Machine* origMach = NULL;
429 try {
430 origMach = dsdb.architecture(configuration.architectureID);
431 } catch (const Exception& e) {
432 debugLog(std::string("No machine architecture found in config id "
433 "by MimimizeMachine plugin. "));
434 delete origMach;
435 return confToMinimize;
436 }
437
439 modifier.analyzeRegisters(*origMach, origRegisterMap);
440
441 CostEstimates estimates;
442
444 startConf.architectureID = dsdb.addArchitecture(*origMach);
445 startConf.hasImplementation = false;
446
447 // evaluates the desing with all dsdb apps
448 if (!explorer.evaluate(startConf, estimates, false)) {
449 // can't evaluate the given configuration
450 delete origMach;
451 origMach = NULL;
452 return confToMinimize;
453 }
454
455 // check if some apps maxCycles was exceeded
456 if (!checkCycleCounts(startConf, maxCycleCounts)) {
457 delete origMach;
458 origMach = NULL;
459 return confToMinimize;
460 }
461
462 MachineResourceModifier::RegisterMap::const_iterator registerMapIter =
463 origRegisterMap.begin();
464
465 ObjectState* currentState = origMach->saveState();
466 // go through all different register file types
467 for (; registerMapIter != origRegisterMap.end(); registerMapIter++) {
469 mach.loadState(currentState);
472
473 int i = 0;
474 rfNav = mach.registerFileNavigator();
475 // go through every register file in the machine to find matching RF
476 while (i < rfNav.count()) {
477 if (((*registerMapIter).second)->isArchitectureEqual(
478 *rfNav.item(i))) {
479
480 // remove the register file
481 mach.removeRegisterFile(*rfNav.item(i));
482 std::list<std::string> socketList;
483 modifier.removeNotConnectedSockets(mach, socketList);
484
485 DSDBManager::MachineConfiguration newConfiguration;
486 RowID confID = 0;
487 CostEstimates newEstimates;
488
489 // if the evaluation fails the removed RF is needed
490 // and the old machine state is loaded
491 if (!evalNewConfigWithoutImplementation(explorer, mach,
492 dsdb, newConfiguration, confID, newEstimates)) {
493
494 // continue with old machine state and
495 // try with next register file type
496 break;
497 }
498
499 // check every apps new cycle counts against
500 // maxCycleCounts
501 if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
502 // continue with old machine state and
503 // try with next register file type
504 break;
505 }
506 latestConfID = confID;
507
508 // save the new machine state
509 delete currentState;
510 currentState = mach.saveState();
511
512 // else continue removing same register types
513 // no need to advance the rf navigator,
514 // because of the removal
515 continue;
516 }
517 // if the registers did not match, try next one in the machine
518 i++;
519 }
520 }
521
522 delete origMach;
523 origMach = NULL;
524 if (latestConfID != 0) {
525 return latestConfID;
526 } else {
527 // no new config could be created
528 return confToMinimize;
529 }
530 }
531
532 /**
533 * Reduces the number of function units in the machine as much as possible
534 * to still achieve the application run time requirements.
535 *
536 * This function won't handle implementations.
537 *
538 * @param confToMinimize ID of the machine configuration which function units
539 * are reduced.
540 * @param maxCycleCounts Max cycle counts per program.
541 * @return ID of the new congiguration where function units are reduced or
542 * same that was given if nothing was done.
543 */
545 RowID confToMinimize,
546 std::vector<ClockCycleCount>& maxCycleCounts) {
547
548 DSDBManager& dsdb = db();
549 RowID latestConfID = 0;
550
552 DesignSpaceExplorer explorer;
553 explorer.setDSDB(dsdb);
554
556 dsdb.configuration(confToMinimize);
557
558 const TTAMachine::Machine* origMach = NULL;
559 try {
560 origMach = dsdb.architecture(configuration.architectureID);
561 } catch (const Exception& e) {
562 debugLog(std::string("No machine architecture found in config id "
563 "by MimimizeMachine plugin. "));
564 delete origMach;
565 return confToMinimize;
566 }
567
569 modifier.analyzeFunctionUnits(*origMach, origFUMap);
570
571 CostEstimates estimates;
573 startConf.architectureID = dsdb.addArchitecture(*origMach);
574 startConf.hasImplementation = false;
575
576 if (!explorer.evaluate(startConf, estimates, false)) {
577 // can't evaluate the given configuration
578 delete origMach;
579 origMach = NULL;
580 return confToMinimize;
581 }
582
583 // check if some apps maxCycles was exceeded
584 if (!checkCycleCounts(startConf, maxCycleCounts)) {
585 delete origMach;
586 origMach = NULL;
587 return confToMinimize;
588 }
589
590 MachineResourceModifier::FunctionUnitMap::const_iterator fuMapIter =
591 origFUMap.begin();
592
593 ObjectState* currentState = origMach->saveState();
594
595 // go through all different function unit types
596 for (; fuMapIter != origFUMap.end(); fuMapIter++) {
598 mach.loadState(currentState);
601 int i = 0;
602 // go through every function unit in the machine to find matching FU
603 while (i < fuNav.count()) {
604 if (((*fuMapIter).second)->isArchitectureEqual(
605 fuNav.item(i), true)) {
606
607 mach.removeFunctionUnit(*fuNav.item(i));
608 std::list<std::string> socketList;
609 modifier.removeNotConnectedSockets(mach, socketList);
610
611 DSDBManager::MachineConfiguration newConfiguration;
612 RowID confID = 0;
613 CostEstimates newEstimates;
614
615 // if the evaluation fails the removed FU is needed
616 // and the old machine state is loaded
617 if (!evalNewConfigWithoutImplementation(explorer, mach,
618 dsdb, newConfiguration, confID, newEstimates)) {
619
620 // continue with old machine state and
621 // try with next FU type
622 break;
623 }
624
625 // goes through every apps new cycles
626 if (!checkCycleCounts(newConfiguration, maxCycleCounts)) {
627 // continue with old machine state and
628 // try with next register file type
629 break;
630 }
631 latestConfID = confID;
632
633 // save the new machine state
634 delete currentState;
635 currentState = mach.saveState();
636
637 // continue removing same FU type
638 // no need to advance the FU navigator,
639 // because of the removal
640 continue;
641 }
642 // if the units did not match, try next one in the machine
643 i++;
644 }
645 }
646 delete origMach;
647 origMach = NULL;
648 if (latestConfID != 0) {
649 return latestConfID;
650 } else {
651 // no new config could be created
652 return confToMinimize;
653 }
654 }
655
656
657 /**
658 * Create, store and evaluate a new configuration without implementation.
659 *
660 * @param explorer Design space explorer to use to evaluate.
661 * @param mach machine for the new configuration.
662 * @param dsdb Design space database to store the new configuration.
663 * @param newConfiguration New machine configuration.
664 * @param confID Row ID of the new configuration in the DSDB.
665 * @param newEstimates Estimates that are calculated during evaluation.
666 * @return true if evaluation succeed, if not, return false.
667 */
668 inline bool
670 DesignSpaceExplorer& explorer, const TTAMachine::Machine& mach,
671 DSDBManager& dsdb, DSDBManager::MachineConfiguration& newConfiguration,
672 RowID& confID, CostEstimates& newEstimates) {
673 try {
674 newConfiguration.architectureID = dsdb.addArchitecture(mach);
675 } catch (const RelationalDBException& e) {
676 // Error occurred while adding adf to the dsdb, adf
677 // probably too big
678 throw e;
679 }
680 newConfiguration.hasImplementation = false;
681
682 try {
683 confID = dsdb.addConfiguration(newConfiguration);
684 } catch (const KeyNotFound& e) {
685 throw e;
686 }
687
688 return explorer.evaluate(newConfiguration, newEstimates, false);
689 }
690
691 /**
692 * Checks that max cycle counts are not exceeded.
693 *
694 * Expects that maxCycleCount vector contains cycle counts for the
695 * matching programs in the same order as the estimates.
696 *
697 * @param estimates Estimations that contain cycle counts.
698 * @param maxCycleCounts Maximum cycle counts of the applications.
699 * @return true if maximum cycle counts are not exceeded, false otherwise.
700 */
703 const std::vector<ClockCycleCount>& maxCycleCounts) {
704
705
706 std::vector<ClockCycleCount> cycleCounts;
707 std::set<RowID> appIds = db().applicationIDs();
708 for (std::set<RowID>::const_iterator appI = appIds.begin();
709 appI != appIds.end(); ++appI) {
710 RowID appID = *appI;
711 if (!db().hasCycleCount(appID, conf.architectureID)) {
712 abortWithError("there was no cycle count?");
713 }
714 cycleCounts.push_back(
715 db().cycleCount(appID, conf.architectureID));
716 }
717
718 for (int i = 0; i < (int)cycleCounts.size(); i++) {
719 // if no time constraints
720 if (maxCycleCounts.at(i) < 1) {
721 continue;
722 }
723 // if some apps maxCycles was exceeded
724 if (maxCycleCounts.at(i) < cycleCounts.at(i)) {
725 return false;
726 }
727 }
728 return true;
729 }
730};
731
732// parameter names
733const std::string MinimizeMachine::minBusPN_("min_bus");
734const std::string MinimizeMachine::minFUPN_("min_fu");
735const std::string MinimizeMachine::minRFPN_("min_rf");
736const std::string MinimizeMachine::frequencyPN_("frequency");
737
#define debugLog(text)
#define abortWithError(message)
#define assert(condition)
int RowID
Type definition of row ID in relational databases.
Definition DBTypes.hh:37
#define EXPORT_DESIGN_SPACE_EXPLORER_PLUGIN(PLUGIN_NAME__)
#define UINT(OPERAND)
Definition OSAL.hh:313
#define BOOL()
CycleCount ClockCycleCount
Alias for ClockCycleCount.
static std::string toString(const T &source)
double area() const
double longestPathDelay() const
RowID addArchitecture(const TTAMachine::Machine &mom)
TTAMachine::Machine * architecture(RowID id) const
std::set< RowID > applicationIDs() const
IDF::MachineImplementation * implementation(RowID id) const
MachineConfiguration configuration(RowID id) const
std::string applicationPath(RowID id) const
RowID addImplementation(const IDF::MachineImplementation &impl, double longestPathDelay, CostEstimator::AreaInGates area)
bool hasCycleCount(RowID application, RowID architecture) const
RowID addConfiguration(const MachineConfiguration &conf)
void readCompulsoryParameter(const std::string paramName, T &param) const
void readOptionalParameter(const std::string paramName, T &param) const
void addParameter(TCEString name, ExplorerPluginParameterType type, bool compulsory=true, TCEString defaultValue="", TCEString description="")
virtual void setDSDB(DSDBManager &dsdb)
virtual DSDBManager & db()
virtual bool evaluate(const DSDBManager::MachineConfiguration &configuration, CostEstimates &results=dummyEstimate_, bool estimate=false)
void removeBusImplementation(const std::string &unitName)
std::multimap< double, TTAMachine::RegisterFile * > RegisterMap
Map of register amounts in percents.
bool removeBuses(const int &countToRemove, TTAMachine::Machine &mach, std::list< std::string > &removedBusNames)
std::multimap< double, TTAMachine::FunctionUnit * > FunctionUnitMap
Map of function unit amounts in percents.
void analyzeRegisters(const TTAMachine::Machine &mach, RegisterMap &registerMap) const
void analyzeFunctionUnits(const TTAMachine::Machine &mach, FunctionUnitMap &unitMap) const
void removeNotConnectedSockets(TTAMachine::Machine &mach, std::list< std::string > &removedSocketNames)
unsigned int frequency_
running frequency in MHz for apps
RowID minimizeBuses(RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
static const std::string frequencyPN_
bool checkCycleCounts(const DSDBManager::MachineConfiguration &conf, const std::vector< ClockCycleCount > &maxCycleCounts)
RowID minimizeMachine(RowID confToMinimize)
virtual bool producesArchitecture() const
static const std::string minBusPN_
virtual bool requiresSimulationData() const
RowID minimizeRegisterFiles(RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
virtual bool requiresHDB() const
RowID minimizeFunctionUnits(RowID confToMinimize, std::vector< ClockCycleCount > &maxCycleCounts)
static const std::string minRFPN_
virtual std::vector< RowID > explore(const RowID &configurationID, const unsigned int &)
bool evalNewConfigWithoutImplementation(DesignSpaceExplorer &explorer, const TTAMachine::Machine &mach, DSDBManager &dsdb, DSDBManager::MachineConfiguration &newConfiguration, RowID &confID, CostEstimates &newEstimates)
bool minRF_
minimize register files
bool minBus_
minimize busses
PLUGIN_DESCRIPTION("Removes resources until the real time " "requirements of applications are not reached anymore.")
static const std::string minFUPN_
bool minFU_
minimize function units
virtual bool requiresStartingPointArchitecture() const
ComponentType * item(int index) const
virtual RegisterFileNavigator registerFileNavigator() const
Definition Machine.cc:450
virtual FunctionUnitNavigator functionUnitNavigator() const
Definition Machine.cc:380
virtual BusNavigator busNavigator() const
Definition Machine.cc:356
virtual void loadState(const ObjectState *state)
Definition Machine.cc:728
virtual ObjectState * saveState() const
Definition Machine.cc:686
virtual void removeFunctionUnit(FunctionUnit &unit)
Definition Machine.cc:530
virtual void removeRegisterFile(RegisterFile &unit)
Definition Machine.cc:554
Runtime maxRuntime() const