libc malloc alternatifleri

Giriş

libc dışında alternatif olarak kullanılabilecek başka heap kütüphaneleri de mevcut.

gnu malloc Problemi Nedir?

Açıklaması şöyle

Under the hood, GNU malloc uses various data structures to make memory allocations more efficient. One such data structure is a collection of heaps. When the application calls malloc, one of these heaps is searched for a contiguous free chunk of memory big enough to fit the request. When the application calls free, a chunk of the heap frees up, which can be reused by a future malloc call. An important detail is that only the topmost chunk of each heap is available for returning to the OS. All empty chunks in the middle of heaps will technically be unused, but still count towards the memory the application is using. This is a very simplified view of what’s happening; check the glibc wiki for a complete overview of GNU malloc internals.

Şeklen şöyle

Bu da aslında bazen fazla bellek kullanılmasına sebep oluyor. Açıklaması şöyle. Kullanılan bellek oranı mallinfo() çağrısı ile görülebilir. gdb ile bağlanıp mallinfo() yapmak gerekiyor.

As you might imagine, there could be many chunks in the malloc heaps just sitting around empty, depending on the pattern of malloc and free calls an application executes. At this point we were wondering if this kind of memory fragmentation could explain the Fulfillment Service’s ever growing memory usage. While investigating possible ways to confirm this, we happened upon an excellent article from the LinkedIn engineering team, describing a problem extremely similar to ours. However, instead of using the gdb-heap tool the LinkedIn team used, we decided to confirm our hypothesis in a slightly more direct way.

It turns out that GNU malloc already exposes some statistics which are suitable for roughly quantifying memory fragmentation. The statistics we are interested in are: the total size of memory in use by the application, the total size of memory in malloc’s heaps but not in use by the application and the part of that memory allowed to be returned to the OS. GNU malloc’s mallinfo function returns these as the uordblks, fordblks and keepcost fields respectively. So, calculating 1 — uordblks / (fordblks — keepcost) gives the ratio of unused memory that cannot be returned to the OS, a measure of memory fragmentation.

Bu çağrının döndürdüğü şey şeklen şöyle

gdb ve java birlikte kullanımı için açıklama şöyle

Having learned this, we created a local testing setup of the Fulfillment Service. This setup consisted of a Docker container with gdb (the GNU debugger for debugging native code), OpenJDK with debug symbols and glibc with debug symbols. This setup allowed us to attach gdb to the JVM and call the mallinfo function from the gdb prompt.

1. jemalloc

github sayfası burada. Açıklaması şöyle. Eğer MALLOC_CONF değişkeni atanırsa, uygulama .heap uzantılı dosyalar üretir, bu dosyalar jeprof komutu ile okunaklı hale getirilebilir.

These two functions, malloc and free, are implemented in their own library. The default on most flavors of Linux is GNU malloc, but it can be swapped out for other implementations. One such implementation is jemalloc, which conveniently also allows tracking where malloc is being called from. This gives us the opportunity to see whether there are any native functions allocating increasing amounts of memory.

On Linux, jemalloc can be enabled by bundling its shared library with an application and setting the LD_PRELOAD environment variable to the location of libjemalloc.so before running Java. Memory profiling can be enabled through the MALLOC_CONF environment variable. The jemalloc wiki contains some useful examples. You can check the jemalloc man page for a full reference of these options. Now our application writes .heap files after a set volume of allocations. These files can be parsed using the jeprof command into something human-readable.

jemalloc ile ilgili bir başka açıklama şöyle. jemalloc tüm malloc() çağrılarını takip etmiyor ancak örnekleme yapıyor.

Jemalloc only samples memory allocations instead of measuring every single malloc call to prevent excessive resource consumption. Therefore, the output of jeprof cannot be directly interpreted as the number of bytes currently in use. However, it does allow us to spot any suspicious functions allocating native memory. Additionally, we could also spot functions that are holding on to significantly more memory relative to others (potentially indicating a memory leak).

Örnek

Şöyle yaparız

export LD_PRELOAD=/usr/local/lib/libjemalloc.so

# tell jemalloc to write a profile to the disk every few 1Gb allocations 
# and record a stack trace (referenced from the blog):
export MALLOC_CONF=prof:true,lg_prof_interval:30,lg_prof_sample:17

# jeprof*.heap. isimli dosyalar oluşur
# dosyalardan rapor oluştur
jeprof --show_bytes --gif /path/to/jvm/bin/java jeprof*.heap > /tmp/app-profiling.gif

2. tcmalloc
Örneğin TCMalloc google tarafından kullanılıyor.

$ LD_PRELOAD="/usr/lib/libtcmalloc.so"yaparak yeniden derlemeye ihtiyaç duymadan kullanılabilir. Açıklaması şöyle.

TCMalloc assigns each thread a thread-local cache. Small allocations are satisfied from the thread-local cache. Objects are moved from central data structures into a thread-local cache as needed, and periodic garbage collections are used to migrate memory back from a thread-local cache into the central data structures.

std::integral Constraint

Giriş

Bu bir constraint. Açıklaması şöyle

... concept like std::integral constrains the deduced type to be an integral type, such as int or long, but not float, or std::string.

Örnek

Şöyle yaparız

std::integral auto something(){
  return 0;
}

int main(){
  const auto x = something();
  return x;
}

alloca metodu - standart C metodu değildir Kullanmayın

Giriş

Şu satırı dahil ederiz

#include <alloca.h>

Bu metod standart C veya POSIX metodu değildir. Gnu C kütüphanesinde bulunur. Windows'ta ise _alloca() şeklinde kullanılabilir.

Bu metod stack üzerinde yer ayırır. Açıklaması şöyle

The alloca() function allocates size bytes of space in the stack frame of the caller. This temporary space is automatically freed when the function that called alloca() returns to its caller.

alloca vs Variable Length Array (VLA)

alloca metodu VLA'dan da eskidir. Açıklaması şöyle. BSD 3 1970'lerin sonuna doğru vardı.

CONFORMING TO

This function is not in POSIX.1-2001.

There is evidence that the alloca() function appeared in 32V, PWB, PWB.2, 3BSD, and 4BSD. There is a man page for it in 4.3BSD. Linux uses the GNU version.

Aslında bu metoda C dilinde gerek yoktur! Çünkü C dili variable length array (VLA) kullanarak stack üzerinde boyutu runtime'da belirlenen yer ayırabilmeye imkan verir.

Ancak C++ variable length array kullanımına izin vermediği için bazen faydalı olabiliyor.

Örnek

alloca yerine VLA kullanılabileceğini görmek için şöyle yaparız

#include <stdio.h>
#include <alloca.h>

void foo(int n)
{
    int a[n];
    int *b=alloca(n*sizeof(int));
    int c[n];
    printf("&a=%p, b=%p, &c=%p\n", (void *)a, (void *)b, (void *)c);
}

int main()
{
    foo(5);
    return 0;
}

Örnek
Örnekte placement new için yer alloca ile stack üzerinde oluşturuluyor.

std::isalpha metodu

Giriş

Bu metod ile ASCII karakterlerin alfabetik olup olmadığı belirlenebilir. Bu metod parametre olarak int alır.

int isalpha ( int c );

Ancak c parametresi unsigned char değeri alacak şekilde sınırlandığı için yalnızca ASCII karakterler için çalışır. Açıklaması ise aşağıda.

The c argument is an int, the value of which the application shall ensure is representable as an unsigned char or equal to the value of the macro EOF. If the argument has any other value, the behavior is undefined.

std::isprint metodu

Giriş

Şu satırı dahil ederiz

#include <cctype>

Örnek

Şöyle yaparız.

char c = ...;
if (isprint(c)) {
  ...
}

std::isspace metodu

Giriş

Şu satırı dahil ederiz

#include <cctype>

Örnek

Şöyle yaparız.

char c = ...;
if (isspace(c)) {
...
}

Deleted Function

Giriş

Deleted Constructor

Deleted Destructor

olabilir.

Ayrıca deleted generic function da olabilir.

Örnek

Şöyle yaparız

// API function
void api(void* p) {
  // ... 
}

// Special case for nullptr
inline void api(std::nullptr_t) {
  api((void*)nullptr);
}

// Everything else is disabled
template <class ...T>
void api(T&&... t) = delete;

int main() {
  int i = 0;
  void* p = &i;
  api(p); // Compiles
  // api(&i); // Doesn't compile
}

std::views::common metodu

Giriş

std::ranges::range tipinden olan değişkeni, STL Container gibi kullabilmeyi sağlar.

Örnek

Şöyle yaparız

template <std::ranges::range R>
auto to_vector(R&& r) {
    auto r_common = r | std::views::common;
    return std::vector(r_common.begin(), r_common.end());
}

Örnek

Şöyle yaparız

#include <cmath>
#include <numeric>
#include <ranges>
#include <utility>

template<typename Container>
auto mean_and_stddev(const Container& values)
{
  auto len = static_cast<double>(values.size());
  auto mean = std::accumulate(values.begin(), values.end(), 0.0) / len;
  auto sdv =                   // squared differences view
      values
      | std::views::transform([mean](auto d){ auto x = d - mean; return x*x; })
      | std::views::common;
  auto stddev = std::sqrt(std::accumulate(sdv.begin(), sdv.end(), 0.0) / len);
  return std::pair{ mean, stddev };
}

C++ Filename Extensions

Giriş

C++ ve bir çok daha başka dil (Pascal, BASIC, C gibi) dosya uzantısının ne olması gerektiğini belirtmez. Bjarne Stroustrup'un "The C++ Programming Language (2nd edition, 1991)" kitabındaki Ch.4, p114'teki açıklaması şöyle açıklaması şöyle

Header files are conventionally suffixed by .h and files containing function or data definitions by .c. ... Other conventions, such as .C, .cxx, .cpp, and .cc, are also found. The manual for your compiler will be quite specific about this issue.

Name Mangling - Sadece C++'ta Vardır

Giriş

Açıklaması şöyle. Yani Linker için gereklidir.

Name mangling is the encoding of function and variable names into unique names so that linkers can separate common names in the language. 

Eğer C kütüphanesini C++ ile kullanmak istersek name mangling olmasını istemeyiz. Bu durumda extern "C" kullanmak gerekir.

Örnek

Açıklaması şöyle

If you have ever looked at an objdump of a C++ program, you have likely seen something like this:

_ZN3foo3bar3bazI6sampleEE3quxvi3fo

This is a C++ mangled symbol, which encodes the namespaces, classes, and function/template arguments, using the Itanium ABI.

Specifically, it is for the following function:

void foo::bar::baz<sample>::qux(int, foo);

Rakamların açıklaması şöyle

- All mangled symbols start with _Z.

- Everything is case sensitive.

- All identifiers are encoded as <length><name>, where <length> is the positive length of <name> in base 10, so foo is encoded as 3foo, sample is encoded as 6sample, etc.

std::chrono::year_month_day

Örnek

Şöyle yaparız. Bu kod UTC saate göre çalışır

#include <chrono>

bool IsTodayChristmas() {
    using namespace std::chrono;

    constexpr month_day Christmas = {December / 25};
    auto Now = year_month_day{floor<days>(system_clock::now())};

    // either
    return Now == Christmas / Now.year();
    // or
    return Now.month() / Now.day() == Christmas;
}

Yerel zamana göre çalışmak istersek şöyle yaparız

bool IsTodayChristmas() {
    using namespace std::chrono;

    constexpr month_day Christmas = {December / 25};
    auto Now_local = current_zone()->to_local(system_clock::now());
    auto Today = year_month_day{floor<days>(Now_local)};

    return Today == Christmas / Today.year();
}

std::map.erease metodu

erase metodu - C++98

İmzası şöyle

void erase (iterator pos);           // (until C++11)

Açıklaması şöyle

The erase operations of the node-based containers (maps, sets, lists) invalidate only iterators and references to the element that was erased, but not any other iterators.

Yani sadece erase edilen eleman'a olan iterator bozulur. Bir başka thread içinde diğer elemanlara iterator varsa bunlar etkilenmez.

STL içindeki bazı veri yapıları kendisine ait erase() metoduna geçilen iterator nesnesini otomatik olarak ilerletiyor. Ancak map bu veri yapılarından değil. erase() metodu void dönüyor. Dolayısıyla döngü içinde bir şey silmek istiyorsak aşağıdakine benzer bir kod parçası kullanmamız gerekli.

for (it = tableMap.begin(); it != tableMap.end(); )
{
    if (tableId == it->first.first) { tableMap.erase(it++); }
    else                            { ++it; }
}

erase metodu - C++11
İmzası şöyle. Iterator const kabul ediliyor.

iterator erase (const_iterator pos ); // (since C++11)

Metod artık iterator dönüyor. Şöyle yaparız.

auto it = m_map.erase(beginIt, endIt);

erase metodu - C++17
İmzası şöyle. Niçin const'luktan sonra bu metod gerekti bilmiyorum.

iterator erase (iterator pos );       // (since C++17)

erase ile silme

Açıklaması şöyle. Yani silinen elemana iterator geçersiz hale gelir.

References and iterators to the erased elements are invalidated. Other references and iterators are not affected.

Örnek - reverse iterator

reverse iterator ile direkt silme doğru değil. reverse iterator önce base() metodu ile forward itertor halie getirilir ve daha sonra silinir. Şöyle yaparız. 

map<int,int> mymap = {{1,0},{2,1},{9,2},{10,3},{11,4}};
for(auto it = mymap.rbegin(); it != mymap.rend(); ){
    auto v = --(it.base());
    v = mymap.erase(v);
    it = map<int,int>::reverse_iterator(v);
}