In order to continuously increase design productivity, engineers and researchers rely on automation frameworks for hardware design purposes. This does not only guarantee an easier implementation of components, but creates a larger margin for improvement by generating design variants. Within this framework, a major problem for optimizing the generated design is retrieving data from which a prediction function (e.g. area, speed, power consumption) could be learned correctly (since a complete generation, i.e. synthesis of the hardware design, is too computationally expensive to be performed for a wide set of variants). In particular, the data used for learning the prediction function should be representative of valid design possibilities and be generated in an e cient way. As one contribution, this paper describes how Statistical Analysis (SA) and Machine Learning (ML) are used to guarantee the quality of the data. At the same time, its retrieval should avoid time consumption and manual e ort. Therefore, this paper also proposes an automatic approach to generate representative and valid con guration samples both to improve the e ciency and to avoid manual e ort during the retrieval. To point out this concept, we implement the generation of data for the estimation of the area of a Register Interface (RI) component. The proposed methods, implemented through SA and ML, allow to supervise the correctness of the generated data and the learning process itself. As a consequence, given the correctly generated data, the process of learning the RI area through a data-driven ML algorithm guarantees a still accurate (R2 = 0:98) but 600x faster estimation.
In order to cope with the increasing complexity in hardware and system design,
a common approach is to rely on higher levels of abstractions. For this reason,
model-based design ows utilizing modeling languages such as UML [
In the following, we focus on MetaRTL [
However, the generation mechanism itself is a challenge, since the generation framework must be resilient, robust and easily maintainable. Indeed, while the meta-model provides a basis for the designs generation, the designer still has to provide a corresponding con guration, i.e. a set of parameters guiding the design generation process and de ning how the meta-model is instantiated/realized. For example, from an abstract description (meta-model) of the CPU structure, the designer has to select a speci c con guration for a CPU instance (e.g. No. of cores, etc.). The complexity of today's hardware components makes it hard to determine a proper set of con gurations which indeed yields a design satisfying given objectives e.g. with respect to area, speed, etc. This raises the question how to e ciently determine instances, from a given meta-model, which eventually trigger the desired design generation.
In order to retrieve an optimal design con guration for a given objective, the designer needs to be equipped with a set of di erent con gurations as well as estimates about the resulting area, speed, etc. of the design obtained from each of these con gurations. While the same could be achieved manually (implementing a set of di erent con gurations and, through a synthesis tool, obtaining the corresponding area, speed, etc.), this would result in a time consuming process. Moreover, the estimates would be prone to errors since, as long as not a \real" implementation would be created for each con guration, the designer would need to infer those characteristics from the design itself. Hence, an automated and reliable way of exploring the space of design con gurations is needed.
In this work, we address these problems. First, we automatically generate
values for the design con gurations from a given meta-model of a RI, a
common hardware component which regulates the data-transfer between CPU and
peripheral devices. Then, we utilize methods of Statistical Analysis (SA) and
Machine Learning (ML) for evaluating the structure of the generated data. This
is done through an analysis of the features correlation, features clustering and
Mutual Information (MI): that captures statistical relatedness and
commonalities of correctly as well as incorrectly generated data. By training a ML algorithm
on correctly generated data, we are able to maximize the prediction accuracy
(R2 = 0:98) [
Experimental evaluations con rm the bene ts of the proposed method. While, thus far, designers mainly determined the needed con gurations by experience, the proposed approach provides them with a powerful tool which automatically suggests proper con gurations, and learn successively a correct objective prediction (e.g. area, speed). Moreover, the SA and ML allows to hint to designers characteristics of the hardware components which were not obvious in the rst place just by manually checking out the single design instances.
The rest of this paper is structured as follows. Section 2 reviews the applied hardware designs generation ow based on MetaRTL and motivates the problem considered in this work. Section 3 then presents the proposed method and outlines how datasets of hardware design con gurations are generated, and how methods of SA and ML are applied for analyzing their quality and correctness. Finally, Section 4 summarizes the obtained results and Section 5 concludes the paper. 2
With the purpose of keeping this work self-contained, this section brie y reviews the automation framework MetaRTL, which is considered in this work as a representative of a model-based approach for generating hardware designs starting from meta-models. Afterwards, we outline the main challenge of the corresponding hardware designs generation ow, namely how to e ciently and correctly obtain hardware con gurations compliant to the requirements of the design (w.r.t. the complementary metrics such as area, speed, etc.). Determining which con guration indeed satis es imposed constraints for the desired objectives is a non-trivial task. 2.1
The MetaRTL Design Flow
The MetaRTL framework (originally proposed in [
The MetaRTL generation- ow follows the three level Model Driven Architecture (MDA) abstractions, and is optimized for supporting the hardware generation. The rst layer, called Model-of-Things (MoT), captures the abstract formalized con gurations, which corresponds to the Computation Independent Model (CIM) in the original MDA description. The second layer, called Modelof-Design (MoD) corresponds to the Platform Independent Model (PIM) and de nes the micro-architecture for the given hardware speci cation. This is the core model for MetaRTL, as it de nes the hardware architecture. The third layer, namely the Model-of-View (MoV) corresponds to the Platform Speci c Model (PSM) and is the least abstract model with a mapping to the target view. It can be conceptualized as a Abstract Syntax Tree (AST), de ned by an abstraction of the target low-level design implementation. 2.2
Open Problem: Determining the Desired Con guration Using the MetaRTL ow described in Section 2.1, di erent hardware designs can be generated from the same meta-model. To this end, a meta-model is de ned rst in the MoT layer which provides a generic description of the system and/or application to be realized. With this respect, the problem we address in this paper is how to correctly and automatically map con gurations of hardware designs (i.e. instances of the meta-model) to output predictions on a learned function. In order to achieve this, we develop methods for generating potential design con gurations and inspect their statistical properties. In the remainder of this work we describe this process, as well as our contributions for improving it, by means of the following running example.
Example 1. We consider a Register Interface (RI) application as example. To this end, a meta-model (as shown in Figure 1) is created. This de nes dependencies and relations between the RI sub-components. The meta-model is composed of four main classes, namely the Interface, the Unit, the Bit eld and the Contained. The Interface class contains all the properties of the same, including most importantly the DataWidth and the AddressWidth of each Interface. Each Interface can contain one or more Units, i.e. logic entities which group the Bit elds. Each Unit is indeed related to one or more Bit elds by means of the Contained component, which are pointers to the Bit elds and allows to decouple them to a single Unit usage. The Bit elds are the minimal information set that we can read and write at once in the RI, and real center of the meta-model.
With the meta-model available, the designer can instantiate di erent hardware realizations by setting parameters, which we denote as input values (or feature values ) for the prediction. With features we indicate instead each attribute to which the input values are referred. The respective parameters are thereby usually restricted through explicit constraints for avoiding completely invalid results. Furthermore, the respectively chosen values will eventually a ect the quality of the generated hardware designs e.g. with respect to area, speed, etc. Outputs
Bit elds Size (X2) No. Bit elds (X3)
No. Units (X4) No. HwRd (X5) 0 No. HwWr (X6) 0 No. SwRd (X7) 0 No. SwWr (X8) 0 No. Virtual (X9)
No. DC (X10) 0 No. LUTs (Y1)
No. SRs (Y2) 0 0 0 x5 x6 x7 x8 0 x10 x1 x2 x3 0 x4 u x4 u x4 u
m Example 2. Consider again the meta-model of the running example shown in Figure 1. Instances of this meta-model are restricted by constraints as shown in Table 1, e.g. the total number of instances of the component Unit is limited by the value of the maximum number of Units, denoted with m, while the size of the Unit is identi ed by u. This allows to reduce the single feature space and adapt the generator to realistic use cases. Each feature may eventually a ect the generate designs with respect to area, speed, etc. For the area prediction of the RI component, we enlisted as outputs of the prediction Look Up Tables (No. LUTs ) and the number of the Slice Registers (No. SRs) generated in the synthesis process. These values in fact determine the surface of the implemented RI component.
Now, the challenge is how to properly determine the values for these features. Although, as stated above, the con gurations values de ne the quality of the generated design e.g. with respect to area, speed, etc., their relation is often not obvious. More precisely, the designer is faced with the question, how to determine a set of possible con gurations which eventually allow to optimize the desired objectives (e.g. instantiating a realization with a certain area, power, etc.). This problem has often a non-trivial solution: by increasing the number of features, a higher number of combinations has to be considered. Some of these will be considered as valid (e.g. No. SwRd + No. HwRd > 0 etc.), some of them are falling out of the valid con gurations subset (e.g. No. SwRd + No. HwRd = 0, etc.). Finally, enlarging the features space may introduce non-obvious e ects, complicating the interdependence in the data.
In the following, we propose a solution to this problem. In order to ease the corresponding descriptions, we thereby focus on determining proper con gurations which generate designs satisfying an area prediction task (further objectives such as speed can then be addressed in a similar fashion). As an output for the prediction problem, we forecast the amount of LUTs and SRs generated in the synthesis run. More speci cally, in order to optimize objectives of the design con gurations (e.g. chip area, cost, speed, etc.), we need a set of generated data, from which the prediction function can be determined. For these data to be a valid input, they should be compliant to de ned constraints and present speci c statistical relations among their features. In fact, as we generate data sharing the same constraints for each dataset, these properties could be observed and o er a glimpse on the correctness of the con gurations. Furthermore, these conditions allow to learn, through a data driven approach, an accurate, robust and representative approximation of the true design values. This is of high interest for preventing the designer from selecting erroneous settings and carry them to a further implementation process. This could indeed escalate in wrong designs and poorly evaluated manufacturing products, which would lead to high costs and expensive re-design solutions. 3
Hardware Synthesis tools are able to take as input the hardware design generated from MoT les, and output the number of Con gurable Logic Blocks (CLBs) and the implementation of the intended hardware function. From the synthesis report, the area of the hardware design is identi ed by number of LUTs and SRs that constitute the CLBs. This approach has two main drawbacks for optimization purposes. First of all, it does not explicitly return the function to be optimized. Second, it requires manual e ort and computation power, as the process implies the synthesis of the hardware implementation of the whole platform. ML algorithms can overcome these issues, by learning to map the design con gurations to the desired prediction. This approach needs nevertheless correctly generated data to learn from. Without those, it is impossible to have a reliable data-driven algorithm. To this end, in this section we propose ML and SA as viable methods for supervising the automated generation of data, structuring a robust and rapid rst step for an optimization work- ow. This approach overcomes the synthesis run for retrieving the area of the design and outlines a prediction function for performing this task. 3.1
The Problem of Area Forecast
In this paper, we generate con gurations as input data for a supervised
learning problem, in the form of a multiple regression. The output variables are the
No. LUTs and No. SRs, indicated as Y1 and Y2. The predictors, usually named
features, are denoted with X1; : : : ; X10 and are retrieved from the MoT con
gurations. The dataset is composed of n = 319 MoTs data samples and can be
represented as f(x(1); y(1)); : : : ; (x(n); y(n))g, where each x(i) = (x(1i); x(2i); : : : ; x(pi))T
is the vector of feature measurements for the i-th case. The amount of
generated data is dependent on the attening of the learning curve of the algorithm
for the area forecast: this shows that additional samples would not enhance the
prediction score of the ML model. For an in-depth description of the regression
problem and ML algorithms applied, we refer to this paper [
Data Generation and Features Space Exploration In order to create a robust generator, we establish a range of possible feature values given by the design required implementations. This means that the congurations have to match with the design experience on application use cases. As a consequence, the computational time for generating a representative sampling is reduced. The con guration boundaries used for this paper, referred to the RI design, are shown in the column Constraints of the Table 1. Even if the constraints restrict the space of search for the optimal RI area, the number of possible features combinations leads to a non-trivial problem. Our approach for randomizing the data generator is to sample, within the constraints of the RI, the Units and Bit elds properties. In addition to that, in each generation we apply one out of four mapping functions, inspired by possible design use cases, for setting the Bit elds inside the Units. The algorithms used to map the Units are the following: { Compact mapping algorithm: dense Bit elds mapping inside each Unit; { Random mapping algorithm: random number of Bit elds mapped inside each
Unit; { Basic mapping algorithm: one Bit eld mapped inside each Unit; { Combined mapping algorithm: jointly use of Basic and Compact mapping algorithms. 3.3
Analysis of the Generated Data The automated data generation is a fast and exible way to retrieve input data for any data-driven algorithms. This process nonetheless has some caveats. In fact, the generation of wrongly constrained data is pernicious for an accurate area forecasting. Further than that, the dataset generated for the learning model, in case of non-trivial problems, should represent extensively the values of the features provided. After building a data generator, in this paper we address thus this problem: we present several approaches for testing the data-generator and evaluating the correctness of the generated dataset. In our case the data generator is implemented through a python script which samples, as aforementioned, from a constrained features space.
The rst step of the proposed solutions consists in measuring the correlation among features for the generated datasets. This value indicates how much features are dependent on each other, giving an intuition on how a feature value changes according to other ones. In order to achieve this, we iteratively plot the features values of the dataset, two at times: it results that the correlation among features is mainly monotonic, i.e. either the variables increase in value together, or as one variable value increases, the other variable value decreases. According to these considerations, we compute the Spearman's Rank Correlation Coe cient (SRCC) on the predictors, two at a time. The SRCC, denoted with , expresses the relation between the distance d between the feature components xi and yi and the number of samples n. This coe cient provides an overview of the features correlation inside the RI, and can be computed, if the ranks are distinct integers, as = 1 6 P d2
i n(n2 1) (1) - d: pairwise distance of the ranks of the observations xi and yi of the variables
X and Y ; - n: number of samples.
As a second support for the identi cation of wrong constraints in the data generator, we apply an agglomerative clustering algorithm, a subset of the family of hierarchical clustering. This approach, from a data-driven perspective, reconstructs the context of the given features, by grouping them together. This procedure allows to match the designer's prior information about the features used with the clusters retrieved in the data. As a rst step, we exclude the presence of outliers after performing an analysis on the generated design features. After an evaluation of di erent linkage methods on our data, we decide to adopt the average linkage clustering. In fact, we aim to nd averaged statistics that match the given design knowledge on the meta-model structure and this linkage performs a meaningful clustering on the data. In the average linkage clustering, the distance between clusters is computed as the mean distance among elements (i.e. the mean of the distance d(x; y), corresponding to the modulus of the difference of the two elements x and y) of each pair of clusters in the dataset, as shown in the following equation
D(H; G) = 1
X kG kH x2G;y2H d(x; y) where d(x; y) represents the distance between x and y, which belong to clusters G and H, respectively.
- d(x; y): distance between x 2 G and y 2 H; - G, H: clusters; - kG, kH : No. of elements, respectively in clusters G, H. (2) (3)
Starting from a single cluster per feature, the algorithm iteratively merges them until the desired groups number Q, set previously by a speci c hyperparameter, is reached. As a criterion for the agglomeration, the algorithm merges clusters where the mean distance between pair of elements is the least among all clusters at each cycle. The nal outcome of the algorithm is a number of clusters Q which include T features, with Q < T.
As a further approach to the analysis of the generated data, we introduce
a features selection algorithm for measuring how each feature in uences the
nal prediction of number of LUTs and SRs. We use ranking algorithms to
highlight the di erent importance of each feature for predicting the two output
responses. The corresponding importance is computed by means of the MI. This
metric, indeed, does not assume any monotonic relationship among features,
but considers only the degree of their relatedness. The ML algorithm applied
computes the MI from the K-Nearest-Neighbors (KNNs) statistics. This value
comes from an iterative process applied to the independent variable X (e.g. No.
Units, X4) and the dependent output variable Y (e.g. No. LUTs, Y1) in order
to quantify the impact of X on the uctuation of Y . In the paper [
I(X; Y ) = (k)
1=k+ (sx) + (sy) + (n) - I(X; Y ): MI between the variable X and the variable Y; - : digamma function, de ned as (x) 1d (x)=dx; - ::: : average over all i 2 [1; : : : ; n]; - sx: number of datapoints with jjxi xj jj x(i)=2, where x(i)=2 is the distance from zi = (xi; yi) to the k-th datapoint projected in the X subspace; - sy: number of datapoints with jjyi yj jj y(i)=2, where y(i)=2 is the distance from zi = (xi; yi) to the k-th datapoint projected in the Y subspace; - n: number of samples. 3.4
Machine Learning for Area Forecast
We proceed, after the data generation and validation, into the area forecast
problem. ML provides a set of algorithms for functions approximation: this has been
often exploited in the hardware design literature for the forecast and
optimization of power consumption [
In the algorithm, we average out the prediction and hidden layer size for 30
di erent models (emodels = 30). Each model performs a nested 4-folds CV for
nding the best test scores (outer 4-folds CV), best parameters (inner 4-folds
CV) and grid search over the hidden layers size (inner 4-folds CV). As a solver,
after a comparative search, we apply a Quasi-Newton method, called L-BFGS.
The algorithm is based on the BFGS recursion for the inverse Hessian matrix
H. The L-BFGS method approximates the Hessian with a rst order matrix
with sparse vectors, in order to limit the usage of memory of the algorithm,
as shown in [
With the scope of evaluating the SA and ML pipeline, we generate a Baseline Dataset (BD) by implementing the aforementioned mapping algorithms and other three anomalous datasets of 200 samples each. These latter cases contravene the constraints imposed in the original random generator, and they gradually enhance the severity level of the anomalies. We consider the following anomalous datasets:
{ ADI: dataset with an additional number of empty Units; { ADII: dataset where all Bit elds created are not readable by hardware devices nor software; { ADIII: dataset where one or more Bit elds are included in the same Unit several times.
The anomalous datasets bypass in an incremental way the set of constraints of the BD dataset: it is important to remark that the anomalies are present on the dataset level (population), as we create each dataset with prede ned mapping and constraints. Thus, we focus on dataset statistics, and not on single design (individual) analysis. As a st approach to the analysis of the generated data, we compute and plot the Spearman's between features. The outcome of the analysis is a symmetric matrix. The SRCC is bounded in the interval 1 1, where = 1 means a full-inverse correlation, = 0 indicates an absence of correlation, and = 1 corresponds to a full-direct correlation. In Figure 2 we plot the correlation values for the BD dataset. For the anomalous datasets, we only provide some comments on the changed coe cients, by observing their correlation matrix.
As expected, we can observe here the intrinsic structure of the RI, in a statistical fashion. Indeed, the min( BD) = 0:68 corresponds to the correlation between Containeds Size and No. Bit elds. This shows the decoupling in the RI between the Contained and the Bit eld component, so that a reference to a same Bit eld can be added in di erent Units several times. For the anomalous datasets, we point out the following principal changes. In ADI, all the Bit elds properties have a low correlation w.r.t. the No. Units, as in the dataset there exists an additional random number of empty Units. In the ADII, we notice that there are no correlation values between the No. HwRd and No. SwRd properties, whereas the No. HwWr and No. SwWr have tighter bound to the No. Bit elds ( = 0:98), as either the HwWr or the SwWr property needs to be True, for the Bit eld to be valid. Last, we observe a correlation interval decrease in ADIII (0 ADIII 1). In particular, the Bit elds Size and Containeds Size are fully uncorrelated with the No. Units, since Bit elds and Containeds are redundant in the Units ( ADIII = 0 and ADIII = 0). The correlation between features (X1;X4) (X2;X4) clearly varies, according to the entity of the anomaly in the data.
As a second step for the features analysis, in order to reconstruct meaningful groups of features in the dataset, we use an agglomerative clustering ML algorithm with average linkage. The table shows the nal clustering results of the algorithm. As number of nal clusters to be outlined, we select Q = 5. The value of Q is chosen based on a features analysis of the RI meta-model since, from design experience, it is possible to retrieve 5 features groups in this component. As show in Table 2, for the BD, all features related to the Bit eld properties compose the Cluster1BD. In the same way, other related entities concerning the Units (e.g. Containeds Size (X1) and No. Units (X4)) are kept in the same cluster (Cluster2BD), whereas independent properties are set in a separate onefeature cluster. In the ADI, the No. Units (X4) are separated from other clusters (Cluster2ADI ), whereas most of the Bit eld properties are kept together, as a result of the basic mapping algorithm and the presence of empty Units. With respect to the ADII, it is possible to observe the same cluster including the No. HwRd (X5) and No. SwRd (X7) features, as the corresponding properties HwRd and SwRd are both constantly set to False (Cluster3ADII ). In a similar fashion the No. HwWr (X6) and No. SwWr (X8) contribute to the same Cluster1ADII , as the properties HwWr and SwWr are likely to be set to True. Finally, we observe how in the ADIII the Containeds Size (X1) and Bit elds Size (X2) are positioned by the algorithm in a same cluster (Cluster4ADIII ), whereas the No. Units (X4) does not have any other agglomerated features (Cluster3ADIII ). This shows how the repetition of Bit eld references in the Containeds lets their relatedness to the Units diminish. The obtained results outline proximity and distances among features for the BD, ADI, ADII and ADIII, and show the different internal structure of the datasets. In particular we observe that, for the BD, the algorithm can retrieve correctly all the assumed clusters of features in the design, di erently than for the anomalous datasets case.
As a nal step of the features analysis, we evaluate the importance and ranking of each single feature w.r.t. the outputs of our regression by means of the MI score. In Figure 3 it is shown how each single feature is related to No. LUTs. The MI between predictors and the response variable No. LUTs is very high for the BD, with a 0:75 M IBD 1:77. In particular, No. Units and Containeds Size have the highest MI with the No. LUTs value. From a design experience point of view, this seems feasible. Observing the MI of the
ADI, the range is 0:60 M IADI 1:17. In particular, features with high MI for the BD are not ranked similarly for the ADI (e.g. No. Units have the last ranking position for the ADI dataset). Concerning the ADII, it is noticeable, as by constraints, the absence of MI between No. SwRd, No. HwRd and the No. LUTs. Furthermore, the features ranking appears di erent and the total MI (M Itot) decreases (M ItBotD = 10.85, M ItAoDtII = 4.22). Finally in ADIII, because of the di erent constraints of the dataset and anomalies produced, the total MI equals M ItAoDtIII = 1.2, with about 9x reduction from M ItBotD w.r.t. the No. LUTs.
Fig. 3: MI on the No. LUTs
We evaluate as well the MI between each one of the features and the response variable No. SRs, as shown in Figure 4. Con rming the hardware design knowledge, the most important feature in the M IBD ranking w.r.t. the No. SRs is the Bit elds Size, that is the aggregated size of all the bit elds present in the RI. The MI shared between the two variables is in fact M I(BXD2;Y2) = 1.76. As a second feature for importance, the No. Bit elds has a M I(BXD3;Y2) = 1.43; this ranking position matches as well with the designer knowledge. The M ItBotD = 12.57, whereas it results lower for the ADI, where M ItAoDtI = 10.52. The M ItAoDtI is furthermore distributed in a more uniform way, showing that the di erent degree of relatedness between M I(AXD2I;Y2) and between M I(AXD3I;Y2) is diminishing the relative importance of X2 and X3. The reason behind that is the additive number of empty units and the consequently lower bit eld density in the ADI. The two remaining datasets have a much lower M Itot, respectively M ItAoDtII = 0.54 and M ItAoDtIII = 0.17. The lower values of MI w.r.t. the No. SRs are due to the very little information between the single feature and the output. This is particularly evident in the M ItAoDtIII where, adding repetitively the same bit eld to a unit, the relatedness of the aggregated bit eld properties towards the units and the nal value of No. SRs clearly decreases.
The results obtained show that features ranking and M ItBotD diverge deeply from the anomalous to the representative dataset. This serves as a valuable metric for assessing the quality and representativeness of the generated designs.
After ensuring the quality of the generated dataset, we implement the ML
algorithm for the area prediction, as described in detail in [
Fig. 4: MI on the No. SRs of the search show 9 No. Neurons 11. The R2 averaged score of the nested CV (inner k-folds with k = 4, outer k-folds with k = 4) is R2 = 0:98 in the test phase, which guarantees a satisfactory prediction score, as well as convergence with the training score and robustness. The Root of the Mean Squared Error (RMSE) in terms of LUTs, is 57, where 432 No. LUTs 3246 and the mean No:LUT s = 1456.7. The RMSE in terms of SRs is 33, where 73 No. SRs 857 and the mean No:SRs = 432.3. In the inference phase, which consists in the area prediction once the model is trained, the estimation is 600x faster than the synthesis run for obtaining the RI area value. 5
In this paper, we reviewed and analyzed ML and SA algorithms for supporting the process of automated data generation in the design con guration. Through the example of the RI, we could show how SA and ML can help in the correct learning of a mapping function to the RI area in a certain constraints boundary, and express useful metrics for pinpointing the validity and quality of the design settings. Indeed, the algorithms used are able to detect incorrectly generated datasets, which could lead to a skewed or invalid area prediction. This leads to a fundamental contribution to the ML area estimation algorithm which, through representative data, can forecast the RI area with R2 = 0:98 and 600x faster than the design generation - synthesis cycle. As a future work, we plan to increase the number of hardware components considered and approach further objectives through ML algorithms. This would determine additional dependencies, but also increase the potential of the proposed solutions. As the problem will grow in dimensionality, we think that ML and SA may be even more valuable methods for supporting hardware design con gurations, objectives optimization and for understanding complex relations among design features. 6
This project was partially funded by BMBF and supported by ITEA under the umbrella of COMPACT.