text: /* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  ==============================================================================*/
  
  #include "tensorflow/lite/kernels/internal/reference/fully_connected.h"
  
  #include "arm_nnfunctions.h"
  #include "tensorflow/lite/c/builtin_op_data.h"
  #include "tensorflow/lite/c/common.h"
  #include "tensorflow/lite/kernels/internal/common.h"
  #include "tensorflow/lite/kernels/internal/quantization_util.h"
  #include "tensorflow/lite/kernels/internal/reference/integer_ops/fully_connected.h"
  #include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
  #include "tensorflow/lite/kernels/kernel_util.h"
  #include "tensorflow/lite/micro/kernels/cmsis-nn/scratch_buffer.h"
  
  namespace tflite {
  namespace ops {
  namespace micro {
  namespace fully_connected {
  namespace {
  
  struct OpData {
    // The scaling factor from input to output (aka the 'real multiplier') can
    // be represented as a fixed point multiplier plus a left shift.
    int32_t output_multiplier;
    int output_shift;
    // The range of the fused activation layer. For example for kNone and
    // uint8_t these would be 0 and 255.
    int32_t output_activation_min;
    int32_t output_activation_max;
    // The index of the temporary tensor where the quantized inputs are cached.
    int input_quantized_index;
  };
  
  constexpr int kInputTensor = 0;
  constexpr int kWeightsTensor = 1;
  constexpr int kBiasTensor = 2;
  constexpr int kOutputTensor = 0;
  
  TfLiteStatus CalculateOpData(TfLiteContext* context,
                               TfLiteFullyConnectedParams* params,
                               TfLiteType data_type, const TfLiteTensor* input,
                               const TfLiteTensor* filter,
                               const TfLiteTensor* bias, TfLiteTensor* output,
                               OpData* data) {
    TfLiteStatus status = kTfLiteOk;
    if (data_type != kTfLiteFloat32) {
      double real_multiplier = 0.0;
      TF_LITE_ENSURE_STATUS(GetQuantizedConvolutionMultipler(
          context, input, filter, bias, output, &real_multiplier));
      int exponent;
      QuantizeMultiplier(real_multiplier, &data->output_multiplier, &exponent);
      data->output_shift = -exponent;
      TF_LITE_ENSURE_STATUS(CalculateActivationRangeQuantized(
          context, params->activation, output, &data->output_activation_min,
          &data->output_activation_max));
    }
    return status;
  }
  
  }  // namespace
  
  void* Init(TfLiteContext* context, const char* buffer, size_t length) {
    return nullptr;
  }
  
  void Free(TfLiteContext* context, void* buffer) {}
  
  TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
    // todo: call AllocateTemporaryTensor() instead of using
    // get_cmsis_scratch_buffer()
    return kTfLiteOk;
  }
  
  TfLiteStatus EvalQuantizedInt8(TfLiteContext* context, TfLiteNode* node,
                                 TfLiteFullyConnectedParams* params, OpData* data,
                                 const TfLiteTensor* input,
                                 const TfLiteTensor* filter,
                                 const TfLiteTensor* bias, TfLiteTensor* output) {
    RuntimeShape output_shape = GetTensorShape(output);
    const int batches = output_shape.Dims(0);
    const int output_depth = output_shape.Dims(1);
    RuntimeShape filter_shape = GetTensorShape(filter);
    const int filter_dim_count = filter_shape.DimensionsCount();
    const int accum_depth = filter_shape.Dims(filter_dim_count - 1);
  
  #if defined(__ARM_FEATURE_DSP)
    const int32_t buf_size = arm_fully_connected_s8_get_buffer_size(accum_depth);
    int16_t* buf = nullptr;
    TF_LITE_ENSURE_OK(context, get_cmsis_scratch_buffer(context, &buf, buf_size));
    TF_LITE_ENSURE_EQ(
        context,
        arm_fully_connected_s8(
            GetTensorData<int8_t>(input), GetTensorData<int8_t>(filter),
            accum_depth, output_depth, batches, -input->params.zero_point,
            -filter->params.zero_point, data->output_multiplier,
            -data->output_shift, output->params.zero_point,
            GetTensorData<int32_t>(bias), GetTensorData<int8_t>(output),
            data->output_activation_min, data->output_activation_max, buf),
        ARM_MATH_SUCCESS);
  #else
  #pragma message( \
      "CMSIS-NN optimization for fully_connected not available for this target. Using reference kernel.")
  
    FullyConnectedParams op_params;
    op_params.input_offset = -input->params.zero_point;
    op_params.weights_offset = -filter->params.zero_point;
    op_params.output_offset = output->params.zero_point;
    op_params.output_multiplier = data->output_multiplier;
    // TODO(b/138810107): Figure out whether output shift should be inverted
    op_params.output_shift = -data->output_shift;
    op_params.quantized_activation_min = data->output_activation_min;
    op_params.quantized_activation_max = data->output_activation_max;
  
    reference_integer_ops::FullyConnected(
        op_params, GetTensorShape(input), GetTensorData<int8_t>(input),
        GetTensorShape(filter), GetTensorData<int8_t>(filter),
        GetTensorShape(bias), GetTensorData<int32_t>(bias),
        GetTensorShape(output), GetTensorData<int8_t>(output));
  #endif
    return kTfLiteOk;
  }
  
  TfLiteStatus EvalQuantized(TfLiteContext* context, TfLiteNode* node,
                             TfLiteFullyConnectedParams* params, OpData* data,
                             const TfLiteTensor* input,
                             const TfLiteTensor* filter, const TfLiteTensor* bias,
                             TfLiteTensor* output) {
    const int32_t input_offset = -input->params.zero_point;
    const int32_t filter_offset = -filter->params.zero_point;
    const int32_t output_offset = output->params.zero_point;
  
    tflite::FullyConnectedParams op_params;
    op_params.input_offset = input_offset;
    op_params.weights_offset = filter_offset;
    op_params.output_offset = output_offset;
    op_params.output_multiplier = data->output_multiplier;
    // Legacy ops used mixed left and right shifts. Now all are +ve-means-left.
    op_params.output_shift = -data->output_shift;
    op_params.quantized_activation_min = data->output_activation_min;
    op_params.quantized_activation_max = data->output_activation_max;
  
  #define TF_LITE_FULLY_CONNECTED(output_data_type)                      \
    reference_ops::FullyConnected(                                       \
        op_params, GetTensorShape(input), GetTensorData<uint8_t>(input), \
        GetTensorShape(filter), GetTensorData<uint8_t>(filter),          \
        GetTensorShape(bias), GetTensorData<int32_t>(bias),              \
        GetTensorShape(output), GetTensorData<output_data_type>(output))
    switch (output->type) {
      case kTfLiteUInt8:
        TF_LITE_FULLY_CONNECTED(uint8_t);
        break;
      case kTfLiteInt16:
        TF_LITE_FULLY_CONNECTED(int16_t);
        break;
      default:
        context->ReportError(
            context,
            "Quantized FullyConnected expects output data type uint8 or int16");
        return kTfLiteError;
    }
  
    return kTfLiteOk;
  }
  
  TfLiteStatus EvalFloat(TfLiteContext* context, TfLiteNode* node,
                         TfLiteFullyConnectedParams* params, OpData* data,
                         const TfLiteTensor* input, const TfLiteTensor* filter,
                         const TfLiteTensor* bias, TfLiteTensor* output) {
    float output_activation_min, output_activation_max;
    CalculateActivationRange(params->activation, &output_activation_min,
                             &output_activation_max);
    tflite::FullyConnectedParams op_params;
    op_params.float_activation_min = output_activation_min;
    op_params.float_activation_max = output_activation_max;
    tflite::reference_ops::FullyConnected(
        op_params, GetTensorShape(input), GetTensorData<float>(input),
        GetTensorShape(filter), GetTensorData<float>(filter),
        GetTensorShape(bias), GetTensorData<float>(bias), GetTensorShape(output),
        GetTensorData<float>(output));
    return kTfLiteOk;
  }
  
  TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
    auto* params =
        reinterpret_cast<TfLiteFullyConnectedParams*>(node->builtin_data);
  
    const TfLiteTensor* input = GetInput(context, node, kInputTensor);
    const TfLiteTensor* filter = GetInput(context, node, kWeightsTensor);
    const TfLiteTensor* bias = GetOptionalInputTensor(context, node, kBiasTensor);
    TfLiteTensor* output = GetOutput(context, node, kOutputTensor);
  
    TfLiteType data_type = input->type;
    OpData local_data_object;
    OpData* data = &local_data_object;
    TF_LITE_ENSURE_STATUS(CalculateOpData(context, params, data_type, input,
                                          filter, bias, output, data));
  
    switch (filter->type) {  // Already know in/out types are same.
      case kTfLiteFloat32:
        return EvalFloat(context, node, params, data, input, filter, bias,
                         output);
      case kTfLiteInt8:
        return EvalQuantizedInt8(context, node, params, data, input, filter, bias,
                                 output);
  
      case kTfLiteUInt8:
        return EvalQuantized(context, node, params, data, input, filter, bias,
                             output);
  
      default:
        context->ReportError(context, "Type %d not currently supported.",
                             filter->type);
        return kTfLiteError;
    }
    return kTfLiteOk;
  }
  
  }  // namespace fully_connected
  
  TfLiteRegistration* Register_FULLY_CONNECTED() {
    static TfLiteRegistration r = {fully_connected::Init, fully_connected::Free,
                                   fully_connected::Prepare,
                                   fully_connected::Eval};
    return &r;
  }
  
  }  // namespace micro
  }  // namespace ops
  }  // namespace tflite
  