cost-A tiny boost library in C++11​

cost Is anCombining performance with ease of useThe cross-platform C++ basic library of , originally named co, was later changed to cocoyaxi. The former is too short and the latter is too long. The middle way is adopted, and it is changed to cost.

Why is it called cost?A friend used to call it a small boost The library, which is a little smaller than boost, is called cost. How small is it?exist The static library compiled on linux and mac is only about 1M in size. Although small, it provides enough powerful functions:

• Command line parameter and configuration file parsing library (flag)
• High-performance log library (log)
• Unit testing framework (unitest)
• go-style coroutines
• Coroutine-based network programming framework
• Efficient JSON library
• JSON based RPC framework
• Metaphysics-oriented programming
• Atomic operation (atomic)
• Random number generator (random)
• Efficient character stream (fastream)
• efficient string (fastring)
• String manipulation (str)
• time library (time)
• Thread library (thread)
• Timed Task Scheduler
• High-performance memory allocator
• LruMap
• hash library
• path library
• File system operations (fs)
• System operation (os)

The version released this time has jumped directly from v2.0.3 to v3.0.0. The span is very large. It is inperformance,Ease of use,stabilityand other aspects have been comprehensively improved.

performance optimization

memory allocator

A new memory allocator (co/malloc) is implemented in v3.0, it is not a general memory allocator, in free and realloc When you need to add the size information of the original memory block, it may be a little inconvenient to use, but it can simplify the design and improve the performance of the memory allocator.

Common memory allocators, such as ptmalloc, jemalloc, tcmalloc and mimalloc, etc., after the small memory is released, it is likely to be cached by them and not returned to the operating system, which mayCauses the phenomenon of suspected memory leak that the memory usage does not decrease after releasing a large amount of small memory. co/malloc has optimized this. While taking into account the performance, it will return as much of the released memory to the operating system as possible, which is conducive to reducing the memory footprint of the program, and has achieved good results in the actual measurement.

co/malloc also provides co::stl_allocator, which can replace the default allocator std::allocator in STL containers. co/stl.h Some commonly used allocator-replaced containers are provided in , which have performance advantages compared to the std version.

co/malloc has become the default memory allocator used internally by cost. Fastring, fastream, Json, etc. are all based on co/malloc. co/test A simple test code is provided in , which can be compiled and run by executing the following commands:

xmake b mem
xmake r mem -t 4 -s

mo_relaxed    mo_consume    mo_acquire 
mo_release    mo_acq_rel    mo_seq_cst

int i = 0;
uint64 u = 0;
atomic_inc(&i, mo_relaxed);
atomic_load(&i, mo_relaxed);
atomic_add(&u, 3); // mo_seq_cst
atomic_add(&u, 7, mo_acquire);

#include "co/flag.h"
#include "co/log.h"
#include "co/co.h"

int main(int argc, char** argv) {
    flag::init(argc, argv);
    log::init();
    co::init();
    // do something here...
    co::exit();
    return 0;
}

#include "co/flag.h"

int main(int argc, char** argv) {
    flag::init(argc, argv);
    // do something here...
    return 0;
}

DEF_bool(debug, false, "");         // no alias
DEF_bool(debug, false, "", d);      // d is an alias of debug
DEF_bool(debug, false, "", d, dbg); // 2 aliases

#include "co/log.h"

int main(int argc, char** argv) {
    flag::init(argc, argv);

    DLOG << "hello " << 23; // debug
    LOG << "hello " << 23;  // info
    WLOG << "hello " << 23; // warning
    ELOG << "hello " << 23; // error
    FLOG << "hello " << 23; // fatal
    TLOG("rpc") << "hello " << 23;
    TLOG("xxx") << "hello " << 23;

    return 0;
}

// {"a":23,"b":false,"s":"123","v":[1,2,3],"o":{"xx":0}}
Json x = {
    { "a", 23 },
    { "b", false },
    { "s", "123" },
    { "v", {1,2,3} },
    { "o", {
        {"xx", 0}
    }},
};

// equal to x
Json y = Json()
    .add_member("a", 23)
    .add_member("b", false)
    .add_member("s", "123")
    .add_member("v", Json().push_back(1).push_back(2).push_back(3))
    .add_member("o", Json().add_member("xx", 0));

x.get("a").as_int();       // 23
x.get("s").as_string();    // "123"
x.get("s").as_int();       // 123, string -> int
x.get("v", 0).as_int();    // 1
x.get("v", 2).as_int();    // 3
x.get("o", "xx").as_int(); // 0

x["a"] == 23;          // true
x["s"] == "123";       // true
x.get("o", "xx") != 0; // false

#include "co/all.h"

int main(int argc, char** argv) {
    flag::init(argc, argv);

    rpc::Server()
        .add_service(new xx::HelloWorldImpl)
        .start("127.0.0.1", 7788, "/xx");

    for (;;) sleep::sec(80000);
    return 0;
}

curl http://127.0.0.1:7788/xx --request POST --data '{"api":"ping"}'
curl http://127.0.0.1:7788/xx --request POST --data '{"api":"HelloWorld.hello"}'