File Manager

X7ROOT File Manager

Current Path: /opt/alt/alt-nodejs24/root/usr/include/node

opt / alt / alt-nodejs24 / root / usr / include / node /

📁 ..
📄 common.gypi(26.04 KB)
📄 config.gypi(32.07 KB)
📁 cppgc
📄 js_native_api.h(31.28 KB)
📄 js_native_api_types.h(6.87 KB)
📁 libplatform
📄 node.h(68.94 KB)
📄 node_api.h(10.34 KB)
📄 node_api_types.h(1.57 KB)
📄 node_buffer.h(3.6 KB)
📄 node_object_wrap.h(3.78 KB)
📄 node_version.h(4.14 KB)
📁 uv
📄 uv.h(71.1 KB)
📄 v8-array-buffer.h(21.49 KB)
📄 v8-callbacks.h(19.06 KB)
📄 v8-container.h(5.82 KB)
📄 v8-context.h(19.27 KB)
📄 v8-cppgc.h(5.83 KB)
📄 v8-data.h(1.68 KB)
📄 v8-date.h(1.41 KB)
📄 v8-debug.h(5.26 KB)
📄 v8-embedder-heap.h(1.62 KB)
📄 v8-embedder-state-scope.h(1.46 KB)
📄 v8-exception.h(9.52 KB)
📄 v8-extension.h(1.83 KB)
📄 v8-external.h(924 B)
📄 v8-forward.h(1.65 KB)
📄 v8-function-callback.h(23.84 KB)
📄 v8-function.h(4.76 KB)
📄 v8-handle-base.h(4.81 KB)
📄 v8-initialization.h(11.02 KB)
📄 v8-internal.h(69.14 KB)
📄 v8-isolate.h(65.4 KB)
📄 v8-json.h(1.32 KB)
📄 v8-local-handle.h(24.35 KB)
📄 v8-locker.h(3.86 KB)
📄 v8-maybe.h(4.61 KB)
📄 v8-memory-span.h(10.5 KB)
📄 v8-message.h(6.53 KB)
📄 v8-microtask-queue.h(4.79 KB)
📄 v8-microtask.h(861 B)
📄 v8-object.h(40.1 KB)
📄 v8-persistent-handle.h(17.25 KB)
📄 v8-platform.h(49.05 KB)
📄 v8-primitive-object.h(2.53 KB)
📄 v8-primitive.h(36.69 KB)
📄 v8-profiler.h(43.27 KB)
📄 v8-promise.h(5.16 KB)
📄 v8-proxy.h(1.22 KB)
📄 v8-regexp.h(3.1 KB)
📄 v8-sandbox.h(7.47 KB)
📄 v8-script.h(32.36 KB)
📄 v8-snapshot.h(11.6 KB)
📄 v8-source-location.h(2.66 KB)
📄 v8-statistics.h(7.45 KB)
📄 v8-template.h(41.98 KB)
📄 v8-traced-handle.h(12.04 KB)
📄 v8-typed-array.h(11.16 KB)
📄 v8-unwinder.h(4.65 KB)
📄 v8-value-serializer.h(10.56 KB)
📄 v8-value.h(17.22 KB)
📄 v8-version.h(773 B)
📄 v8-wasm.h(6.83 KB)
📄 v8-weak-callback-info.h(2.72 KB)
📄 v8.h(3.69 KB)
📄 v8config.h(34.39 KB)

Editing: v8-locker.h

// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef INCLUDE_V8_LOCKER_H_
#define INCLUDE_V8_LOCKER_H_

#include "v8config.h"  // NOLINT(build/include_directory)

namespace v8 {

namespace internal {
class Isolate;
}  // namespace internal

class Isolate;

/**
 * Multiple threads in V8 are allowed, but only one thread at a time is allowed
 * to use any given V8 isolate, see the comments in the Isolate class. The
 * definition of 'using a V8 isolate' includes accessing handles or holding onto
 * object pointers obtained from V8 handles while in the particular V8 isolate.
 * It is up to the user of V8 to ensure, perhaps with locking, that this
 * constraint is not violated. In addition to any other synchronization
 * mechanism that may be used, the v8::Locker and v8::Unlocker classes must be
 * used to signal thread switches to V8.
 *
 * v8::Locker is a scoped lock object. While it's active, i.e. between its
 * construction and destruction, the current thread is allowed to use the locked
 * isolate. V8 guarantees that an isolate can be locked by at most one thread at
 * any time. In other words, the scope of a v8::Locker is a critical section.
 *
 * Sample usage:
 * \code
 * ...
 * {
 *   v8::Locker locker(isolate);
 *   v8::Isolate::Scope isolate_scope(isolate);
 *   ...
 *   // Code using V8 and isolate goes here.
 *   ...
 * } // Destructor called here
 * \endcode
 *
 * If you wish to stop using V8 in a thread A you can do this either by
 * destroying the v8::Locker object as above or by constructing a v8::Unlocker
 * object:
 *
 * \code
 * {
 *   isolate->Exit();
 *   v8::Unlocker unlocker(isolate);
 *   ...
 *   // Code not using V8 goes here while V8 can run in another thread.
 *   ...
 * } // Destructor called here.
 * isolate->Enter();
 * \endcode
 *
 * The Unlocker object is intended for use in a long-running callback from V8,
 * where you want to release the V8 lock for other threads to use.
 *
 * The v8::Locker is a recursive lock, i.e. you can lock more than once in a
 * given thread. This can be useful if you have code that can be called either
 * from code that holds the lock or from code that does not. The Unlocker is
 * not recursive so you can not have several Unlockers on the stack at once, and
 * you cannot use an Unlocker in a thread that is not inside a Locker's scope.
 *
 * An unlocker will unlock several lockers if it has to and reinstate the
 * correct depth of locking on its destruction, e.g.:
 *
 * \code
 * // V8 not locked.
 * {
 *   v8::Locker locker(isolate);
 *   Isolate::Scope isolate_scope(isolate);
 *   // V8 locked.
 *   {
 *     v8::Locker another_locker(isolate);
 *     // V8 still locked (2 levels).
 *     {
 *       isolate->Exit();
 *       v8::Unlocker unlocker(isolate);
 *       // V8 not locked.
 *     }
 *     isolate->Enter();
 *     // V8 locked again (2 levels).
 *   }
 *   // V8 still locked (1 level).
 * }
 * // V8 Now no longer locked.
 * \endcode
 */
class V8_EXPORT Unlocker {
 public:
  /**
   * Initialize Unlocker for a given Isolate.
   */
  V8_INLINE explicit Unlocker(Isolate* isolate) { Initialize(isolate); }

~Unlocker();

private:
  void Initialize(Isolate* isolate);

internal::Isolate* isolate_;
};

class V8_EXPORT Locker {
 public:
  /**
   * Initialize Locker for a given Isolate.
   */
  V8_INLINE explicit Locker(Isolate* isolate) { Initialize(isolate); }

~Locker();

/**
   * Returns whether or not the locker for a given isolate, is locked by the
   * current thread.
   */
  static bool IsLocked(Isolate* isolate);

// Disallow copying and assigning.
  Locker(const Locker&) = delete;
  void operator=(const Locker&) = delete;

private:
  void Initialize(Isolate* isolate);

bool has_lock_;
  bool top_level_;
  internal::Isolate* isolate_;
};

}  // namespace v8

#endif  // INCLUDE_V8_LOCKER_H_

X7ROOT File Manager

Editing: v8-locker.h

Upload File

Create Folder