highs-sys 1.14.2

Rust binding for the HiGHS linear programming solver. See http://highs.dev.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                       */
/*    This file is part of the HiGHS linear optimization suite           */
/*                                                                       */
/*    Available as open-source under the MIT License                     */
/*                                                                       */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef HIGHS_CACHE_ALIGN_H_
#define HIGHS_CACHE_ALIGN_H_

#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>

namespace highs {

struct cache_aligned {
  static constexpr std::size_t alignment() { return 64; }

  static void* alloc(std::size_t size) {
    using std::uintptr_t;

    uintptr_t ptr =
        reinterpret_cast<uintptr_t>(::operator new(size + alignment()));

    char* aligned_ptr = reinterpret_cast<char*>((ptr | (alignment() - 1)) + 1);
    std::memcpy(aligned_ptr - sizeof(uintptr_t), &ptr, sizeof(uintptr_t));
    return reinterpret_cast<void*>(aligned_ptr);
  }

  static void free(void* aligned_ptr) {
    using std::uintptr_t;

    if (aligned_ptr) {
      void* freeptr;
      std::memcpy(&freeptr,
                  reinterpret_cast<char*>(aligned_ptr) - sizeof(uintptr_t),
                  sizeof(uintptr_t));
      ::operator delete(freeptr);
    }
  }

  template <typename T>
  struct Deleter {
    void operator()(T* ptr) const {
      ptr->~T();
      free(ptr);
    }
  };

  template <typename T>
  struct Deleter<T[]> {
    void operator()(T* ptr) const { free(ptr); }
  };

  template <typename T>
  using unique_ptr = std::unique_ptr<T, Deleter<T>>;

  template <typename T>
  using shared_ptr = std::shared_ptr<T>;

  template <typename T, typename... Args>
  static shared_ptr<T> make_shared(Args&&... args) {
    return shared_ptr<T>(new (alloc(sizeof(T))) T(std::forward<Args>(args)...),
                         Deleter<T>());
  }

  template <typename T, typename... Args>
  static unique_ptr<T> make_unique(Args&&... args) {
    return unique_ptr<T>(new (alloc(sizeof(T))) T(std::forward<Args>(args)...));
  }

  template <typename T, typename... Args>
  static unique_ptr<T[]> make_unique_array(std::size_t N) {
    return unique_ptr<T[]>(static_cast<T*>(alloc(sizeof(T) * N)));
  }
};

}  // namespace highs

#endif