common/memory_image/memory-image.proto

// Copyright (C) 2017 The Android Open Source Project
//
// 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.

// Protos for "memory images".

syntax = "proto2";
option optimize_for = LITE_RUNTIME;

package libtextclassifier.nlp_core;

message MemoryImageDataBlobInfo {
  // Size (in bytes) of this data blob.
  optional uint64 num_bytes = 1;

  // Indicates whether this data blob corresponds to an array.
  optional bool is_array = 2 [default = true];

  // Size (in bytes) of each array element.  Useful for little <-> big endian
  // conversions.  -1 means unknown: no endianness conversion in that case.
  optional int32 element_size = 3 [default = -1];
}

message MemoryImageHeader {
  // Version of the algorithm used to produce the memory image.  We should
  // increase the value used here every time we perform an incompatible change.
  // Algorithm version v should handle only memory images of the same version,
  // and crash otherwise.
  optional int32 version = 1 [default = -1];

  // True if the info stored in the data blobs uses the little endian
  // convention.  Almost all machines today are little-endian but we want to be
  // able to crash with an informative message or perform a (costly) conversion
  // in the rare cases when that's not true.
  optional bool is_little_endian = 2 [default = true];

  // Alignment (in bytes) for all data blobs.  E.g., if this field is 16, then
  // each data blob starts at an offset that's a multiple of 16, where the
  // offset is measured from the beginning of the memory image.  On the client
  // side, allocating the entire memory image at an aligned address (by same
  // alignment) makes sure all data blobs are properly aligned.
  //
  // NOTE: I (salcianu) explored the idea of a different alignment for each data
  // blob: e.g., float[] should be fine with 4-byte alignment (alignment = 4)
  // but char[] are fine with no alignment (alignment = 1).  As we expect only a
  // few (but large) data blobs, the space benefit is not worth the extra code
  // complexity.
  optional int32 alignment = 3 [default = 8];

  // One MemoryImageDataBlobInfo for each data blob, in order.  There is one
  // data blob for each large field we handle specially.
  repeated MemoryImageDataBlobInfo blob_info = 4;
}