Apply review comments

Author: EgorDuplensky

src/plugins/intel_cpu/src/nodes/conv.cpp

@@ -476,7 +476,7 @@ void Convolution::initSupportedPrimitiveDescriptors() {
 
     m_attrs.isGraphQuantized = context->isGraphQuantized();
     m_attrs.fcSemantic = false;
-    m_attrs.nonConstantWeights = !getParentEdgeAt(WEIGHTS)->getParent()->isConstant();
+    m_attrs.constantWeights = getParentEdgeAt(WEIGHTS)->getParent()->isConstant();
     m_attrs.weightsNonTransposed = false;
     m_attrs.dqScales = getDQScales();
 

src/plugins/intel_cpu/src/nodes/executors/convolution_config.hpp

@@ -32,7 +32,8 @@ struct ConvAttrs {
     // @todo can we just check for port precisions instead?
     bool isGraphQuantized = false;
     bool fcSemantic = false;
-    bool nonConstantWeights = false;
+    // there are models with non-constant weights
+    bool constantWeights = true;
     ZeroPointsType inputZeroPointsType = ZeroPointsType::None;
     std::vector<float> dqScales;
 

src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_convolution_primitive.cpp

@@ -98,7 +98,7 @@ DnnlConvolutionPrimitive::IntermediateReorders::IntermediateReorders(const Key&
             createIfNotEqual(key.dst->getDnnlDesc(), primDesc.dst_desc(), AllocateMemoryFor::Dst, engine);
     }
 
-    if (key.nonConstantWeights && key.wei->getDnnlDesc() != primDesc.weights_desc()) {
+    if (!key.constantWeights && key.wei->getDnnlDesc() != primDesc.weights_desc()) {
         m_inputReorders[DNNL_ARG_WEIGHTS] =
             createIfNotEqual(key.wei->getDnnlDesc(), primDesc.weights_desc(), AllocateMemoryFor::Dst, engine);
     }
@@ -142,7 +142,7 @@ size_t DnnlConvolutionPrimitive::Key::hash() const {
 
     seed = hash_combine(seed, get_attr_hash(*attr.get()));
     seed = hash_combine(seed, fcSemantic);
-    seed = hash_combine(seed, nonConstantWeights);
+    seed = hash_combine(seed, constantWeights);
 
     return seed;
 }
@@ -168,7 +168,7 @@ bool DnnlConvolutionPrimitive::Key::operator==(const Key& rhs) const {
 
     result = result && *attr.get() == *rhs.attr.get();
     result = result && fcSemantic == rhs.fcSemantic;
-    result = result && nonConstantWeights == rhs.nonConstantWeights;
+    result = result && constantWeights == rhs.constantWeights;
 
     return result;
 }
@@ -858,7 +858,7 @@ std::shared_ptr<DnnlConvolutionPrimitive> DnnlConvolutionPrimitive::create(
                           paddingR,
                           shapeAgnosticData->m_primAttrs.attr,
                           attrs.fcSemantic,
-                          attrs.nonConstantWeights};
+                          attrs.constantWeights};
 
     const auto defaultImplType = shapeAgnosticData->m_implType;
 

src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_convolution_primitive.hpp

@@ -40,8 +40,8 @@ class DnnlConvolutionPrimitive {
 
         dnnl::primitive_attr attr;
 
-        bool fcSemantic;
-        bool nonConstantWeights;
+        bool fcSemantic = false;
+        bool constantWeights = true;
 
         [[nodiscard]] size_t hash() const;
         bool operator==(const Key& rhs) const;

src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_executor.hpp

@@ -126,7 +126,7 @@ class DnnlExecutor : public Executor {
                              const PrimitivePtr currentPrimitive,
                              const PrimitivePtr newPrimitive,
                              const MemoryPtr& memory) {
-        if (m_attrs.nonConstantWeights) {  // non constant weights are handled by the primitive
+        if (m_attrs.constantWeights) {  // non constant weights are handled by the primitive
             m_primArgs[DNNL_ARG_WEIGHTS] = memory->getPrimitive();
             return;
         }

src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_matmul_primitive.cpp

@@ -543,7 +543,7 @@ DnnlShapeAgnosticDataPtr DnnlMatMulPrimitive::createShapeAgnosticData(const MatM
                                               useWeightsDecompression,
                                               attrs.fcSemantic);
 
-    if (!attrs.nonConstantWeights && cacheWeights) {
+    if (attrs.constantWeights && cacheWeights) {
         const auto weightsDesc = DnnlExtensionUtils::makeDescriptor(primDesc.weights_desc());
         auto originalWeightsDesc = MemoryDescUtils::convertToDnnlMemoryDesc(weiDesc);
 

src/plugins/intel_cpu/src/nodes/executors/executor_factory.hpp

@@ -83,10 +83,14 @@ class ExecutorFactory {
      * - Simple Executor, if there is only one available implementation
      *
      * @param memory memory arguments.
+     * @param initVariableExecutor whether to init first available implementation of variable executor or not.
+     *        This option is mostly a workaround at the moment.
+     *        In general it might be beneficial to initialize all the shape dependent implementations
+     *        of the variable executor in advance to avoid first-time call delays.
      *
      * @return A shared pointer to the created Executor.
      */
-    ExecutorPtr make(const MemoryArgs& memory, bool precreate = true) {
+    ExecutorPtr make(const MemoryArgs& memory, bool initVariableExecutor = true) {
         std::vector<ExecutorImplementationRef> implementations;
 
         auto acceptsConfig = [](const ExecutorImplementationRef& impl, const executor::Config<Attrs>& config) {
@@ -121,7 +125,11 @@ class ExecutorFactory {
             return theOnlyImplementation.create(m_attrs, memory, m_context);
         }
 
-        return std::make_shared<VariableExecutor<Attrs>>(memory, m_attrs, m_context, implementations, precreate);
+        return std::make_shared<VariableExecutor<Attrs>>(memory,
+                                                         m_attrs,
+                                                         m_context,
+                                                         implementations,
+                                                         initVariableExecutor);
     }
 
 private:

src/plugins/intel_cpu/src/nodes/executors/fullyconnected_config.hpp

@@ -20,7 +20,7 @@ struct FCAttrs {
     bool weightsNonTransposed = false;
     bool sparseWeights = false;
     uint64_t dynamicQuantizationGroupSize = 0;
-    bool nonConstantWeights = false;
+    bool constantWeights = true;
 
     ov::intel_cpu::Config::ModelType modelType = ov::intel_cpu::Config::ModelType::Unknown;
 

src/plugins/intel_cpu/src/nodes/executors/fullyconnected_implementations.cpp

@@ -422,6 +422,7 @@ const std::vector<ExecutorImplementation<FCAttrs>>& getImplementations() {
                                         false};
                 matMulAttrs.postOps = attrs.postOps;
                 matMulAttrs.transposeB = attrs.weightsNonTransposed;
+                matMulAttrs.constantWeights = true;
 
                 return std::make_shared<
                     DnnlExecutor<DnnlMatMulPrimitive, MatMulAttrs, DnnlShapeAgnosticData,

src/plugins/intel_cpu/src/nodes/executors/matmul_config.hpp

@@ -19,7 +19,7 @@ struct MatMulAttrs {
     bool weightsNonTransposed = false;
     bool sparseWeights = false;
     uint64_t dynamicQuantizationGroupSize = 0;
-    bool nonConstantWeights = true;
+    bool constantWeights = false;
     bool fcSemantic = false;
 
     // DQ scales for quantization