구차니의 잡동사니 모음

외근했다 사무실 와서 집에 오려고 노력했으나

우산을 버스에 두고 내렸다는 슬픈 이야기 ㅠㅠ

segmentation fault가 떠서 어디서 죽나 찾는데 꽤나 고생했네 -_-

(빌드가 느리면 역시 스트레스..)

그런데 도무지 allocateTensors() 라는 함수가 어떤 역활을 하는지 모르겠네..

한번 할당하고 또 할당하면 오류나는 느낌..

[링크 : https://www.tensorflow.org/lite/guide/inference]

[링크 : https://www.tensorflow.org/lite/api_docs/cc/class/tflite/interpreter#allocatetensors]

여기 소스를 많이 참고했는데.. tensorflow의 label_image쪽이랑은 또 많이 달라서

어느 가이드를 따라가야 하나 고민..

[링크 : https://github.com/Qengineering/TensorFlow_Lite_SSD_RPi_64-bits/blob/master/MobileNetV1.cpp]

mmap()으로 특정 메모리 영역을 접근하는데

이상한 순서로 에러 메시지가 뒤죽박죽 되어 나와서 겨우겨우 복구(?) 해봤더니 더 멘붕오는 듯한 용어만 잔뜩 -_-

ppte는 약어를 못 찾음 (느낌은 pte에 대한 pointer 아닐까 싶긴 하지만..)

[링크 : https://www.kernel.org/doc/gorman/html/understand/understand006.html]

(0x1818) 음.. 딱 적절한 나의 마음을 나타내는 값은 ifsr 레지스터 라는데

[링크 : https://stackoverflow.com/questions/15889483/what-do-these-kernel-panic-errors-mean]

레지스터값의 의미를 요약하면 다음과 같은데

도대체 무슨 말이야!!!

SD Indicates whether an AXI Decode or Slave error caused an abort. This bit is only valid for external aborts. For all other aborts this bit Should Be Zero: 0 = AXI Decode error caused the abort, reset value 1 = AXI Slave error caused the abort. RW Indicates whether a read or write access caused an abort: 0 = read access caused the abort, reset value 1 = write access caused the abort. Domain Indicates which one of the 16 domains, D15-D0, is accessed when a data fault occurs. This field takes values 0-15. Status Indicates the type of exception generated. To determine the data fault, bits [12] and [10] must be used in conjunction with bits [3:0]. The following encodings are in priority order, 1 is the highest: 0b000001 alignment fault 0b000100 instruction cache maintenance fault 0bx01100 L1 translation, precise external abort 0bx01110 L2 translation, precise external abort 0b011100 L1 translation precise parity error 0b011110 L2 translation precise parity error 0b000101 translation fault, section 0b000111 translation fault, page 0b000011 access flag fault, section 0b000110 access flag fault, page 0b001001 domain fault, section 0b001011 domain fault, page 0b001101 permission fault, section 0b001111 permission fault, page 0bx01000 precise external abort, nontranslation 0bx10110 imprecise external abort 0b011000 imprecise error, parity or ECC 0b000010 debug event.

[링크 : https://developer.arm.com/documentation/.../c5--data-fault-status-register]

[링크 : https://github.com/brgl/busybox/blob/master/miscutils/devmem.c]

요근래 기사중에 가장 아픈 곳을 찌르는 기사인듯.

나쁘게 말하면 무슨 국비지원 학원이 이번에 새로 선정되었나 싶을 정도로

학원 광고들이 넘쳐나는 느낌이었는데

콕 찍어서 그런거 해서 돈 벌 수 있는게 아니다.

실제는 정말 천재개발자 하나를 낚기 위한 밑밥일 뿐

이라는 느낌의 기사.

근데 개발자던 코더든 우리나라 환경에서 구분이 가능하긴 한가 싶다.

[링크 : https://news.v.daum.net/v/20210524113608246]

터미널에서 알록달록하게 해주는 그것!

vt 에뮬레이터 결과를 richtextbox로 보낼까.. 아니면 HTML로 보낼까.. 흐음..

[링크 : https://en.wikipedia.org/wiki/ANSI_escape_code]

[링크 : https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797]

영역을 선택하고

선택 영역의 색상을 지정하는 느낌으로 색을 추가한다.

SelectionColor = 글씨 색상 <<

SelectionBackColor = 글씨 배경 색 <<

BackColor = richtextbox 전체 배경 색

[링크 : https://stackoverflow.com/questions/1926264/color-different-parts-of-a-richtextbox-string]

쿨쿨쿨

인터넷 유머글 보다가 댓글에서 갑자기 발견한 부고

21.05.06 사망했고

소식이 알려진 건 21.05.20

좋아했던 독자로서 작가님의 명복을 기원합니다..

[링크 : https://zdnet.co.kr/view/?no=20210520134059]

stdin을 통해 입력을 받아 작동하는 프로그램을 쉘에서 실행하고 백드라운드로 돌리니 멈춘다?!

[링크 : https://topic.alibabacloud.com/...-stopped-tty-input_1_16_30150438.html]

[링크 : https://unix.stackexchange.com/questions/294471/backgrounded-job-keeps-stopping]

아무튼 SIGTTIN이 들어와서 그렇다고 하는데

간단하게는.. 해당 시그널을 무시하면 되는거고..

다른 방법은 좀 더 고민해 봐야 할 듯 -_-

void
init_shell ()
{

  /* See if we are running interactively.  */
  shell_terminal = STDIN_FILENO;
  shell_is_interactive = isatty (shell_terminal);

  if (shell_is_interactive)
    {
      /* Loop until we are in the foreground.  */
      while (tcgetpgrp (shell_terminal) != (shell_pgid = getpgrp ()))
        kill (- shell_pgid, SIGTTIN);

      /* Ignore interactive and job-control signals.  */
      signal (SIGINT, SIG_IGN);
      signal (SIGQUIT, SIG_IGN);
      signal (SIGTSTP, SIG_IGN);
      signal (SIGTTIN, SIG_IGN);
      signal (SIGTTOU, SIG_IGN);
      signal (SIGCHLD, SIG_IGN);

      /* Put ourselves in our own process group.  */
      shell_pgid = getpid ();
      if (setpgid (shell_pgid, shell_pgid) < 0)
        {
          perror ("Couldn't put the shell in its own process group");
          exit (1);
        }

      /* Grab control of the terminal.  */
      tcsetpgrp (shell_terminal, shell_pgid);

      /* Save default terminal attributes for shell.  */
      tcgetattr (shell_terminal, &shell_tmodes);
    }
}

[링크 : https://www.gnu.org/software/libc/manual/html_node/Initializing-the-Shell.html]

[링크 : https://www.gnu.org/software/libc/manual/html_node/Job-Control-Signals.html]

label_image 예제를 보면 get_top_n 에서

(prediction[i] + 128) / 256.0 나 prediction[i] / 255.0 

같은 quantization 범위에 맞춘 무언가가 보이는데 

TfLiteQuantizationParams.scale 와 TfLiteQuantizationParams.zero_point을 이용하면 자동화 가능할 느낌.

template <class T>
void get_top_n(T* prediction, int prediction_size, size_t num_results,
               float threshold, std::vector<std::pair<float, int>>* top_results,
               TfLiteType input_type) {
  // Will contain top N results in ascending order.
  std::priority_queue<std::pair<float, int>, std::vector<std::pair<float, int>>,
                      std::greater<std::pair<float, int>>>
      top_result_pq;

  const long count = prediction_size;  // NOLINT(runtime/int)
  float value = 0.0;

  for (int i = 0; i < count; ++i) {
    switch (input_type) {
      case kTfLiteFloat32:
        value = prediction[i];
        break;
      case kTfLiteInt8:
        value = (prediction[i] + 128) / 256.0;
        break;
      case kTfLiteUInt8:
        value = prediction[i] / 255.0;
        break;
      default:
        break;
    }
    // Only add it if it beats the threshold and has a chance at being in
    // the top N.
    if (value < threshold) {
      continue;
    }

    top_result_pq.push(std::pair<float, int>(value, i));

    // If at capacity, kick the smallest value out.
    if (top_result_pq.size() > num_results) {
      top_result_pq.pop();
    }
  }

  // Copy to output vector and reverse into descending order.
  while (!top_result_pq.empty()) {
    top_results->push_back(top_result_pq.top());
    top_result_pq.pop();
  }
  std::reverse(top_results->begin(), top_results->end());
}

netron 에서 보면 quantization 범위가 나오는데, 어딘가 저장하고는 있는 듯 해서 검색 중

// SupportedQuantizationTypes.
typedef enum TfLiteQuantizationType {
  // No quantization.
  kTfLiteNoQuantization = 0,
  // Affine quantization (with support for per-channel quantization).
  // Corresponds to TfLiteAffineQuantization.
  kTfLiteAffineQuantization = 1,
} TfLiteQuantizationType;

// Structure specifying the quantization used by the tensor, if-any.
typedef struct TfLiteQuantization {
  // The type of quantization held by params.
  TfLiteQuantizationType type;
  // Holds a reference to one of the quantization param structures specified
  // below.
  void* params;
} TfLiteQuantization;

// Legacy. Will be deprecated in favor of TfLiteAffineQuantization.
// If per-layer quantization is specified this field will still be populated in
// addition to TfLiteAffineQuantization.
// Parameters for asymmetric quantization. Quantized values can be converted
// back to float using:
//     real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteQuantizationParams {
  float scale;
  int32_t zero_point;
} TfLiteQuantizationParams;

// Parameters for asymmetric quantization across a dimension (i.e per output
// channel quantization).
// quantized_dimension specifies which dimension the scales and zero_points
// correspond to.
// For a particular value in quantized_dimension, quantized values can be
// converted back to float using:
//     real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteAffineQuantization {
  TfLiteFloatArray* scale;
  TfLiteIntArray* zero_point;
  int32_t quantized_dimension;
} TfLiteAffineQuantization;

typedef struct TfLiteTensor {
  TfLiteType type;
  TfLitePtrUnion data;
  TfLiteIntArray* dims;
  TfLiteQuantizationParams params;
  TfLiteAllocationType allocation_type;
  size_t bytes;
  const void* allocation;
  const char* name;
  struct TfLiteDelegate* delegate;
  TfLiteBufferHandle buffer_handle;
  bool data_is_stale;
  bool is_variable;
  TfLiteQuantization quantization;
  TfLiteSparsity* sparsity;
  const TfLiteIntArray* dims_signature;
} TfLiteTensor;

+

2021.05.26

typedef struct TfLiteIntArray {
  int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
#if (!defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
     __GNUC_MINOR__ >= 1) ||                                      \
    defined(HEXAGON) || (__clang_major__ == 7 && __clang_minor__ == 1)
  int data[0];
#else
  int data[];
#endif
} TfLiteIntArray;

// Fixed size list of floats. Used for per-channel quantization.
typedef struct TfLiteFloatArray {
  int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
// This also applies to the toolchain used for Qualcomm Hexagon DSPs.
#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
    __GNUC_MINOR__ >= 1
  float data[0];
#else
  float data[];
#endif
} TfLiteFloatArray;

class Interpreter {
  /// Invoke the interpreter (run the whole graph in dependency order).
  ///
  /// NOTE: It is possible that the interpreter is not in a ready state
  /// to evaluate (i.e. if a ResizeTensor() has been performed without an
  /// AllocateTensors().
  /// Returns status of success or failure.
  TfLiteStatus Invoke();

  /// WARNING: Experimental interface, subject to change
  Subgraph& primary_subgraph() {
    return *subgraphs_.front();  /// Safe as subgraphs_ always has 1 entry.
  }
  
  /// Read only access to list of inputs.
  const std::vector<int>& inputs() const { return primary_subgraph().inputs(); }
  
  /// Read only access to list of outputs.
  const std::vector<int>& outputs() const {
    return primary_subgraph().outputs();
  }
  
  // Subgraphs
  std::vector<std::unique_ptr<Subgraph>> subgraphs_;
};

[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/interpreter.h]

class Subgraph {
  // Array of indices representing the tensors that are inputs to the
  // interpreter.
  std::vector<int> inputs_;

  // Array of indices representing the tensors that are outputs to the
  // interpreter.
  std::vector<int> outputs_;
  
  // Read only access to list of inputs.
  std::vector<int>& inputs() { return inputs_; }

  // Read only access to list of inputs.
  const std::vector<int>& inputs() const { return inputs_; }

  // Read only access to list of outputs.
  std::vector<int>& outputs() { return outputs_; }

  // Read only access to list of outputs.
  const std::vector<int>& outputs() const { return outputs_; }
};

[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/core/subgraph.h]