sync.h

/* Copyright 2026 Stanford University, NVIDIA Corporation
 *
 * 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.
 */
 
#ifndef __LEGION_SYNCHRONIZATION_H__
#define __LEGION_SYNCHRONIZATION_H__
 
#include "legion/api/types.h"
 
namespace Legion {
 
  class Lock {
  public:
    Lock(void);
  protected:
    // Only the runtime is allowed to make non-empty locks
    FRIEND_ALL_RUNTIME_CLASSES
    Lock(Reservation r);
  public:
    bool operator<(const Lock& rhs) const;
    bool operator==(const Lock& rhs) const;
  public:
    void acquire(unsigned mode = 0, bool exclusive = true);
    void release(void);
  private:
    Reservation reservation_lock;
  };
 
  struct LockRequest {
  public:
    LockRequest(Lock l, unsigned mode = 0, bool exclusive = true);
  public:
    Lock lock;
    unsigned mode;
    bool exclusive;
  };
 
  class Grant {
  public:
    Grant(void);
    Grant(const Grant& g);
    ~Grant(void);
  protected:
    // Only the runtime is allowed to make non-empty grants
    FRIEND_ALL_RUNTIME_CLASSES
    explicit Grant(Internal::GrantImpl* impl);
  public:
    bool operator==(const Grant& g) const { return impl == g.impl; }
    bool operator<(const Grant& g) const { return impl < g.impl; }
    Grant& operator=(const Grant& g);
  protected:
    Internal::GrantImpl* impl;
  };
 
  class PhaseBarrier {
  public:
    PhaseBarrier(void);
  protected:
    // Only the runtime is allowed to make non-empty phase barriers
    FRIEND_ALL_RUNTIME_CLASSES
    PhaseBarrier(Internal::ApBarrier b);
  public:
    bool operator<(const PhaseBarrier& rhs) const;
    bool operator==(const PhaseBarrier& rhs) const;
    bool operator!=(const PhaseBarrier& rhs) const;
  public:
    void arrive(unsigned count = 1);
    void wait(void);
    void alter_arrival_count(int delta);
    Realm::Barrier get_barrier(void) const { return phase_barrier; }
    bool exists(void) const;
  protected:
    Internal::ApBarrier phase_barrier;
    friend std::ostream& operator<<(std::ostream& os, const PhaseBarrier& pb);
  };
 
  class DynamicCollective : public PhaseBarrier {
  public:
    DynamicCollective(void);
  protected:
    // Only the runtime is allowed to make non-empty dynamic collectives
    FRIEND_ALL_RUNTIME_CLASSES
    DynamicCollective(Internal::ApBarrier b, ReductionOpID redop);
  public:
    // All the same operations as a phase barrier
    void arrive(const void* value, size_t size, unsigned count = 1);
  protected:
    ReductionOpID redop;
  };
 
}  // namespace Legion
 
#include "legion/api/sync.inl"
 
#endif  // __LEGION_SYNCHRONIZATION_H__