Initializes global memory array with the given one
333073
def initialize_memory(basic_block):
    
    global MEMORY

    MEMORY = basic_block.mem
    get_labels(MEMORY, basic_block)
    basic_block.mem = MEMORY
333059
private void init() {
        generalHuffsize();
        generalHuffcode();

        int i = 0, j = 0;
        for (;;) {
            i++;

            if (i > 16) {
                break;
            }

            if (L[i] == 0) {
                maxcode[i] = -1;
                continue;
            } else {
                valptr[i] = j;
                mincode[i] = huffcode[j];
                j = j + L[i] - 1;
                maxcode[i] = huffcode[j];
                j++;
            }
        }

        maxcode[17] = 0xFFFFFF;
    }
207576
def _initialize_variables(self):
    """"""
    # Initialize global variables.
    self._global_vars = {}  # Indexed by (MTF dimension, mesh dimension)
    for mtf_dimension_name in (
        self._layout_validator.splittable_mtf_dimension_names):
      for mesh_dimension_name in (
          self._layout_validator.mesh_dimension_name_to_size):
        name = _global_var_name(mtf_dimension_name, mesh_dimension_name)
        self._global_vars[(mtf_dimension_name, mesh_dimension_name)] = (
            self._model.NewBoolVar(name))

    # Initialize local variables.
    self._local_vars = {}  # Indexed by (tensorflow dimension set), then name of
    # assignment.
    for mtf_dimension_set in self._mtf_dimension_sets:
      self._local_vars[mtf_dimension_set] = {}
      for assignment in self._assignments[mtf_dimension_set]:
        # TODO(joshuawang): Avoid hash collision no matter what dimension names
        # are; don't hash by this local var name, swap to using a tuple encoding
        # of the full assignment instead.
        name = _local_var_name(mtf_dimension_set, assignment)
        self._local_vars[mtf_dimension_set][name] = (
            self._model.NewBoolVar(name))

    # Initialize memory variable. We need a crude upper bound on memory, so we
    # use the total size of all tensors under the empty assignment.
    # NOTE(joshuawang): This bound could be improved by factoring in the
    # schedule.
    memory_upper_bound = 0
    for tensor_name in self._graph.get_all_tensor_names():
      if self._graph.is_tensor_on_canonical_device(tensor_name):
        memory_upper_bound += int(self._graph.get_tensor_size(tensor_name))
    self._memory_var = self._model.NewIntVar(0, memory_upper_bound, "z")
476174
def p_GlobalVaribleList(p):
    '''
    
    '''
    if len(p) > 2:
        p[0] = GlobalVaribleList(p[1], p[3])
    else:
        p[0] = GlobalVaribleList(None, p[1])
116220
void initialize(DMatrixSparseCSC A) {
        m = A.numRows;
        n = A.numCols;
        int s = 4*n + (ata ? (n+m+1) : 0);

        gw.reshape(s);
        w = gw.data;

        // compute the transpose of A
        At.reshape(A.numCols,A.numRows,A.nz_length);
        CommonOps_DSCC.transpose(A,At,gw);

        // initialize w
        Arrays.fill(w,0,s,-1); // assign all values in workspace to -1

        ancestor = 0;
        maxfirst = n;
        prevleaf = 2*n;
        first    = 3*n;
    }
1374607
static void initSingleParam(String key, String initValue, DbConn cnx)
    {
        try
        {
            cnx.runSelectSingle("globalprm_select_by_key", 2, String.class, key);
            return;
        }
        catch (NoResultException e)
        {
            GlobalParameter.create(cnx, key, initValue);
        }
        catch (NonUniqueResultException e)
        {
            // It exists! Nothing to do...
        }
    }
1270557
function MemoryAdapter(initialFiles) {
    if (!(this instanceof MemoryAdapter)) {
        return new MemoryAdapter(initialFiles);
    }

    this.entries = new Map();

    // load initial file buffers
    if (typeof initialFiles === "object" && initialFiles) {
        Object.keys(initialFiles).forEach((fileName) => {
            const buf = Buffer.from(initialFiles[fileName]);
            this.entries.set(fileName, buf);
        });
    }
}
279245
def init_with_ary(ary)
      @tuple = Array.new(ary.size)
      @tuple.size.times do |i|
        @tuple[i] = ary[i]
      end
    end
1040576
protected void init() throws IOException {
        try {
            long lwmScn = _arrayFile.getLwmScn();
            long hwmScn = _arrayFile.getHwmScn();
            if (hwmScn < lwmScn) {
                throw new IOException(_arrayFile.getAbsolutePath() + " is corrupted: lwmScn=" + lwmScn + " hwmScn=" + hwmScn);
            }

            // Initialize entry manager and process entry files on disk if any.
            _entryManager.init(lwmScn, hwmScn);

            // Load data from the array file on disk.
            loadArrayFileData();
        } catch (IOException e) {
            _entryManager.clear();
            getLogger().error(e.getMessage(), e);
            throw e;
        }
    }
1142777
def _init(self):
        """"""
        read_values = []
        read = self._file.read
        last = read(1)
        current = read(1)
        while last != b'' and current != b'' and not \
                (last == b'\r' and current == b'\n'):
            read_values.append(last)
            last = current
            current = read(1)
        if current == b'' and last != b'\r':
            read_values.append(last)
        self._bytes = b''.join(read_values)
1116659
@SuppressWarnings("unchecked")
  private void initialize(int capacity) {
    // Find a power of 2 >= capacity
    int tableLength = 16;
    while (tableLength < capacity) {
      tableLength <<= 1;
    }
    // Allocates hash table.
    _entries = new EntryImpl[tableLength];
    _mask = tableLength - 1;
    _capacity = capacity;
    _size = 0;
    // Allocates views.
    _values = new Values();
    _entrySet = new EntrySet();
    _keySet = new KeySet();
    // Resets pointers.
    _poolFirst = null;
    _mapFirst = null;
    _mapLast = null;
    // Allocates entries.
    for (int i = 0; i < capacity; i++) {
      EntryImpl<K, V> entry = new EntryImpl<K, V>();
      entry._after = _poolFirst;
      _poolFirst = entry;
    }
  }
1117623
def init(self):
        ""

        self.length = 0L
        self.input = []

        # Load magic initialization constants.
        self.A = 0x67452301L
        self.B = 0xefcdab89L
        self.C = 0x98badcfeL
        self.D = 0x10325476L
590693
protected void initSpecialArrays() {
        int len = getByteArray().length;
        // set up the "status code + SPACE + default reason phrase"
        this.bytesWithPhrase = new byte[len + 1 + this.myPhraseBytes.length];
        System.arraycopy(getByteArray(), 0, this.bytesWithPhrase, 0, len);
        this.bytesWithPhrase[len] = BNFHeaders.SPACE;
        System.arraycopy(this.myPhraseBytes, 0, this.bytesWithPhrase, len + 1, this.myPhraseBytes.length);
    }
508212
function GlobalMemoryDump(model, start) {
    tr.model.ContainerMemoryDump.call(this, start);
    this.model = model;
    this.processMemoryDumps = {};
  }
316257
function Stack(global1, local, scope, stack) {
            this.global = global1 != null ? global1 : global;
            this.local = local != null ? local : {};
            this.scope = scope != null ? scope : [];
            this.stack = stack != null ? stack : [];
        }
163192
function setValue1fv( gl, v ) {

	var cache = this.cache;

	if ( arraysEqual( cache, v ) ) return;

	gl.uniform1fv( this.addr, v );

	copyArray( cache, v );

}
42812
def build_global_index_updates_array(current_global_indexes)
      indexes_to_update = []
      return indexes_to_update if current_global_indexes.empty?
      current_global_indexes.each do |current_index|
        @global_secondary_indexes.each do |target_index|
          # Find the same named index
          next unless target_index[:index_name] == current_index[:index_name]
          # Skip unless a different ProvisionedThroughput is specified
          break unless (target_index[:provisioned_throughput][:read_capacity_units] !=
                        current_index.provisioned_throughput.read_capacity_units) ||
                       (target_index[:provisioned_throughput][:write_capacity_units] !=
                        current_index.provisioned_throughput.write_capacity_units)
          indexes_to_update << { index_name: target_index[:index_name],
                                 provisioned_throughput: target_index[:provisioned_throughput] }
        end
      end
      puts indexes_to_update
      indexes_to_update
    end