sobjectizer
v.5.8.3
Dibuat oleh GH-MD-TOC
Sobjectizer adalah salah satu dari beberapa "kerangka kerja aktor" lintas platform dan opensource untuk C ++. Tetapi Sobjectizer mendukung tidak hanya model aktor, tetapi juga menerbitkan model berlangganan dan saluran seperti CSP. Tujuan Sobjectizer adalah penyederhanaan yang signifikan dari pengembangan aplikasi bersamaan dan multithreaded di C ++.
Sobjectizer memungkinkan pembuatan aplikasi bersamaan sebagai satu set objek agen yang berinteraksi satu sama lain melalui pesan asinkron. Ini menangani pengiriman pesan dan menyediakan konteks kerja untuk pemrosesan pesan. Dan memungkinkan untuk menyetel hal-hal itu dengan memasok berbagai operator yang siap digunakan.
Kedewasaan . Sobjectizer didasarkan pada ide-ide yang telah diajukan pada tahun 1995-2000. Dan Sobjectizer sendiri sedang dikembangkan sejak tahun 2002. Sobjectizer-5 terus berkembang sejak 2010.
Stabilitas . Sejak awal sobjectizer digunakan untuk aplikasi bisnis-kritis, dan beberapa di antaranya masih digunakan dalam produksi. Melanggar perubahan sobjectizer jarang terjadi dan kami mendekatinya dengan sangat hati -hati.
Cross-Platform . Sobjectizer berjalan di Windows, Linux, FreeBSD, MacOS dan Android.
Mudah digunakan . Sobjectizer menyediakan API yang mudah dimengerti dan mudah digunakan dengan banyak contoh dalam distributif Sobjectizer dan banyak informasi di wiki proyek.
Bebas . Sobjectizer didistribusikan di bawah lisensi BSD-3-Clause, sehingga dapat digunakan dalam pengembangan perangkat lunak komersial berpemilik secara gratis.
Sobjectizer sering dibandingkan dengan alat -alat seperti blok bangunan threading Intel, TaskFlow, HPX, dan mirip dengannya. Perbandingan seperti itu tidak berguna.
Semua alat tersebut dimaksudkan untuk digunakan untuk menyelesaikan tugas dari area komputasi paralel: mereka memungkinkan untuk mengurangi waktu komputasi dengan memanfaatkan beberapa core CPU. Misalnya, Anda dapat meng -ulang kode video Anda dari satu format ke format lain dalam waktu satu jam pada satu inti CPU, dengan hanya membutuhkan waktu 15 menit pada empat core. Itulah tujuan utama komputasi paralel.
Sobjectizer dimaksudkan untuk area yang sedikit berbeda: komputasi bersamaan. Tujuan utama Sobjectizer adalah penyederhanaan melakukan banyak tugas berbeda sekaligus. Terkadang tidak perlu menggunakan lebih dari satu inti CPU untuk itu. Tetapi jika ada beberapa inti CPU, maka Sobjectizer membuat penanganan tugas -tugas itu dan interaksi di antara mereka jauh lebih mudah.
Bagian yang sulit adalah fakta bahwa komputasi paralel dan bersamaan menggunakan mekanisme konkurensi dan primitif yang sama (seperti benang, mutex, atom, dan sebagainya) di bawah kap mesin. Tetapi dari sudut pandang tingkat tinggi komputasi paralel dan bersamaan digunakan untuk tugas yang sangat berbeda.
Sebagai contoh aplikasi yang telah atau dapat diimplementasikan di atas Sobjectizer, kami dapat mendaftarkan proxy-server multithreaded, sistem kontrol otomatis, broker MQ, server database, dan sebagainya.
Ini adalah contoh klasik "halo, dunia" yang diungkapkan dengan menggunakan agen Sobjectizer:
# include < so_5/all.hpp >
class hello_actor final : public so_5:: agent_t {
public:
using so_5:: agent_t :: agent_t ;
void so_evt_start () override {
std::cout << " Hello, World! " << std::endl;
// Finish work of example.
so_deregister_agent_coop_normally ();
}
};
int main () {
// Launch SObjectizer.
so_5::launch ([](so_5:: environment_t & env) {
// Add a hello_actor instance in a new cooperation.
env. register_agent_as_coop ( env. make_agent <hello_actor>() );
});
return 0 ;
}Mari kita lihat contoh yang lebih menarik dengan dua agen dan pertukaran pesan di antara mereka. Ini adalah contoh terkenal lainnya untuk kerangka kerja aktor, "ping-pong":
# include < so_5/all.hpp >
struct ping {
int counter_;
};
struct pong {
int counter_;
};
class pinger final : public so_5:: agent_t {
so_5:: mbox_t ponger_;
void on_pong ( mhood_t <pong> cmd) {
if (cmd-> counter_ > 0 )
so_5::send<ping>(ponger_, cmd-> counter_ - 1 );
else
so_deregister_agent_coop_normally ();
}
public:
pinger ( context_t ctx) : so_5:: agent_t { std::move (ctx)} {}
void set_ponger ( const so_5:: mbox_t mbox) { ponger_ = mbox; }
void so_define_agent () override {
so_subscribe_self (). event ( &pinger::on_pong );
}
void so_evt_start () override {
so_5::send<ping>(ponger_, 1000 );
}
};
class ponger final : public so_5:: agent_t {
const so_5:: mbox_t pinger_;
int pings_received_{};
public:
ponger ( context_t ctx, so_5:: mbox_t pinger)
: so_5:: agent_t { std::move (ctx)}
, pinger_{ std::move (pinger)}
{}
void so_define_agent () override {
so_subscribe_self (). event (
[ this ]( mhood_t <ping> cmd) {
++pings_received_;
so_5::send<pong>(pinger_, cmd-> counter_ );
});
}
void so_evt_finish () override {
std::cout << " pings received: " << pings_received_ << std::endl;
}
};
int main () {
so_5::launch ([](so_5:: environment_t & env) {
env. introduce_coop ([](so_5:: coop_t & coop) {
auto pinger_actor = coop. make_agent <pinger>();
auto ponger_actor = coop. make_agent <ponger>(
pinger_actor-> so_direct_mbox ());
pinger_actor-> set_ponger (ponger_actor-> so_direct_mbox ());
});
});
return 0 ;
}Semua agen dalam kode di atas bekerja pada utas kerja yang sama. Bagaimana cara mengikatnya ke utas kerja yang berbeda?
Itu sangat sederhana. Cukup gunakan operator yang tepat:
int main () {
so_5::launch ([](so_5:: environment_t & env) {
env. introduce_coop (
so_5::disp::active_obj::make_dispatcher (env). binder (),
[](so_5:: coop_t & coop) {
auto pinger_actor = coop. make_agent <pinger>();
auto ponger_actor = coop. make_agent <ponger>(
pinger_actor-> so_direct_mbox ());
pinger_actor-> set_ponger (ponger_actor-> so_direct_mbox ());
});
});
return 0 ;
}Sobjectizer mendukung model pub/sub melalui kotak pesan multi-produser/multi-konsumen. Pesan yang dikirim ke kotak pesan itu akan diterima oleh semua pelanggan jenis pesan itu:
# include < so_5/all.hpp >
using namespace std ::literals ;
struct acquired_value {
std::chrono::steady_clock::time_point acquired_at_;
int value_;
};
class producer final : public so_5:: agent_t {
const so_5:: mbox_t board_;
so_5:: timer_id_t timer_;
int counter_{};
struct acquisition_time final : public so_5:: signal_t {};
void on_timer ( mhood_t <acquisition_time>) {
// Publish the next value for all consumers.
so_5::send<acquired_value>(
board_, std::chrono::steady_clock::now (), ++counter_);
}
public:
producer ( context_t ctx, so_5:: mbox_t board)
: so_5:: agent_t { std::move (ctx)}
, board_{ std::move (board)}
{}
void so_define_agent () override {
so_subscribe_self (). event (&producer::on_timer);
}
void so_evt_start () override {
// Agent will periodically recive acquisition_time signal
// without initial delay and with period of 750ms.
timer_ = so_5::send_periodic<acquisition_time>(* this , 0ms, 750ms);
}
};
class consumer final : public so_5:: agent_t {
const so_5:: mbox_t board_;
const std::string name_;
void on_value ( mhood_t <acquired_value> cmd) {
std::cout << name_ << " : " << cmd-> value_ << std::endl;
}
public:
consumer ( context_t ctx, so_5:: mbox_t board, std::string name)
: so_5:: agent_t { std::move (ctx)}
, board_{ std::move (board)}
, name_{ std::move (name)}
{}
void so_define_agent () override {
so_subscribe (board_). event (&consumer::on_value);
}
};
int main () {
so_5::launch ([](so_5:: environment_t & env) {
auto board = env. create_mbox ();
env. introduce_coop ([board](so_5:: coop_t & coop) {
coop. make_agent <producer>(board);
coop. make_agent <consumer>(board, " first " s);
coop. make_agent <consumer>(board, " second " s);
});
std::this_thread::sleep_for ( std::chrono::seconds ( 4 ));
env. stop ();
});
return 0 ;
}Semua agen di Sobjectizer adalah mesin kondisi-terbatas. Hampir semua fungsionalitas mesin hirarki-states (HSM) didukung: status anak dan pewarisan penangan, On_enter/On_exit Handler, Timeout Negara, Sejarah Negara yang Dalam dan Dangkal, kecuali negara bagian ortogonal.
Mari kita lihat bagaimana agen yang mengimplementasikan Statechart berikut ini bisa terlihat seperti:
Ini adalah contoh yang sangat sederhana yang menunjukkan agen untuk statechart yang ditunjukkan di atas:
# include < so_5/all.hpp >
using namespace std ::literals ;
class blinking_led final : public so_5:: agent_t {
state_t off{ this }, blinking{ this },
blink_on{ initial_substate_of{ blinking } },
blink_off{ substate_of{ blinking } };
public :
struct turn_on_off : public so_5 :: signal_t {};
blinking_led ( context_t ctx) : so_5:: agent_t { std::move (ctx)} {
this >>= off;
off. just_switch_to <turn_on_off>(blinking);
blinking. just_switch_to <turn_on_off>(off);
blink_on
. on_enter ([]{ std::cout << " ON " << std::endl; })
. on_exit ([]{ std::cout << " off " << std::endl; })
. time_limit (1250ms, blink_off);
blink_off
. time_limit (750ms, blink_on);
}
};
int main ()
{
so_5::launch ([](so_5:: environment_t & env) {
so_5:: mbox_t m;
env. introduce_coop ([&](so_5:: coop_t & coop) {
auto led = coop. make_agent < blinking_led >();
m = led-> so_direct_mbox ();
});
const auto pause = []( auto duration) {
std::this_thread::sleep_for (duration);
};
std::cout << " Turn blinking on for 10s " << std::endl;
so_5::send<blinking_led::turn_on_off>(m);
pause (10s);
std::cout << " Turn blinking off for 5s " << std::endl;
so_5::send<blinking_led::turn_on_off>(m);
pause (5s);
std::cout << " Turn blinking on for 5s " << std::endl;
so_5::send<blinking_led::turn_on_off>(m);
pause (5s);
std::cout << " Stopping... " << std::endl;
env. stop ();
} );
return 0 ;
}Sobjectizer memungkinkan untuk menulis aplikasi bersamaan bahkan tanpa agen di dalam. Hanya benang polos dan saluran seperti CSP yang dapat digunakan.
Ini adalah implementasi polos dari contoh ping-pong (harap dicatat bahwa main () tidak aman pengecualian):
# include < so_5/all.hpp >
struct ping {
int counter_;
};
struct pong {
int counter_;
};
void pinger_proc (so_5:: mchain_t self_ch, so_5:: mchain_t ping_ch) {
so_5::send<ping>(ping_ch, 1000 );
// Read all message until channel will be closed.
so_5::receive ( so_5::from (self_ch). handle_all (),
[&](so_5:: mhood_t <pong> cmd) {
if (cmd-> counter_ > 0 )
so_5::send<ping>(ping_ch, cmd-> counter_ - 1 );
else {
// Channels have to be closed to break `receive` calls.
so_5::close_drop_content (so_5::exceptions_enabled, self_ch);
so_5::close_drop_content (so_5::exceptions_enabled, ping_ch);
}
});
}
void ponger_proc (so_5:: mchain_t self_ch, so_5:: mchain_t pong_ch) {
int pings_received{};
// Read all message until channel will be closed.
so_5::receive ( so_5::from (self_ch). handle_all (),
[&](so_5:: mhood_t <ping> cmd) {
++pings_received;
so_5::send<pong>(pong_ch, cmd-> counter_ );
});
std::cout << " pings received: " << pings_received << std::endl;
}
int main () {
so_5:: wrapped_env_t sobj;
auto pinger_ch = so_5::create_mchain (sobj);
auto ponger_ch = so_5::create_mchain (sobj);
std::thread pinger{pinger_proc, pinger_ch, ponger_ch};
std::thread ponger{ponger_proc, ponger_ch, pinger_ch};
ponger. join ();
pinger. join ();
return 0 ;
}Sobjectizer menyediakan fungsi Select () yang mirip dengan pernyataan SELECT Golang. Fungsi ini memungkinkan menunggu pesan masuk dari beberapa rantai pesan. Ini juga memungkinkan untuk menunggu kesiapan rantai pesan untuk menerima pesan keluar baru. Jadi pilih () memungkinkan untuk melakukan panggilan pengiriman () non-blocking dengan penanganan pesan yang masuk sementara rantai pesan target penuh.
Ada contoh perhitungan Fibonacci yang menggunakan Select () sebagai mekanisme tekanan balik (utas produser bilangan akan menunggu jika utas pembaca angka belum membaca nomor sebelumnya). Perhatikan juga bahwa fungsi utama () dalam contoh ini adalah pengecualian-aman.
# include < so_5/all.hpp >
# include < chrono >
using namespace std ;
using namespace std ::chrono_literals ;
using namespace so_5 ;
struct quit {};
void fibonacci ( mchain_t values_ch, mchain_t quit_ch )
{
int x = 0 , y = 1 ;
mchain_select_result_t r;
do
{
r = select (
from_all (). handle_n ( 1 ),
// Sends a new message of type 'int' with value 'x' inside
// when values_ch is ready for a new outgoing message.
send_case ( values_ch, message_holder_t < int >:: make (x),
[&x, &y] { // This block of code will be called after the send().
auto old_x = x;
x = y; y = old_x + y;
} ),
// Receive a 'quit' message from quit_ch if it is here.
receive_case ( quit_ch, [](quit){} ) );
}
// Continue the loop while we send something and receive nothing.
while ( r. was_sent () && !r. was_handled () );
}
int main ()
{
wrapped_env_t sobj;
thread fibonacci_thr;
auto thr_joiner = auto_join ( fibonacci_thr );
// The chain for Fibonacci number will have limited capacity.
auto values_ch = create_mchain ( sobj, 1s, 1 ,
mchain_props:: memory_usage_t ::preallocated,
mchain_props:: overflow_reaction_t ::abort_app );
auto quit_ch = create_mchain ( sobj );
auto ch_closer = auto_close_drop_content ( values_ch, quit_ch );
fibonacci_thr = thread{ fibonacci, values_ch, quit_ch };
// Read the first 10 numbers from values_ch.
receive ( from ( values_ch ). handle_n ( 10 ),
// And show every number to the standard output.
[]( int v ) { cout << v << endl; } );
send< quit >( quit_ch );
}Informasi lebih lanjut tentang sobjectizer dapat ditemukan di bagian yang sesuai dari wiki proyek.
Ada proyek pendamping terpisah SO5Extra yang berisi banyak hal berguna seperti dispatcher berbasis ASIO, jenis mbox tambahan, pengatur waktu yang dapat dibatalkan, permintaan sinkron, dan banyak lagi.
Misalnya, ada bagaimana interaksi sinkron itu terlihat (dengan menggunakan so_5::extra::sync Stuff):
# include < so_5_extra/sync/pub.hpp >
# include < so_5/all.hpp >
// Short alias for convenience.
namespace sync_ns = so_5::extra::sync;
using namespace std ::chrono_literals ;
// The type of service provider.
class service_provider_t final : public so_5:: agent_t
{
public :
using so_5:: agent_t :: agent_t ;
void so_define_agent () override
{
so_subscribe_self (). event (
[]( sync_ns:: request_mhood_t < int , std::string> cmd ) {
// Transform the incoming value, convert the result
// to string and send the resulting string back.
cmd-> make_reply ( std::to_string (cmd-> request () * 2 ) );
} );
}
};
// The type of service consumer.
class consumer_t final : public so_5:: agent_t
{
// Message box of the service provider.
const so_5:: mbox_t m_service;
public :
consumer_t ( context_t ctx, so_5:: mbox_t service )
: so_5:: agent_t { std::move (ctx) }
, m_service{ std::move (service) }
{}
void so_evt_start () override
{
// Issue a request and wait for the result no more than 500ms.
auto result = sync_ns::request_reply< int , std::string>(
// The destination for the request.
m_service,
// Max waiting time.
500ms,
// Request's value.
4 );
std::cout << " The result: " << result << std::endl;
so_deregister_agent_coop_normally ();
}
};
int main ()
{
so_5::launch ( [](so_5:: environment_t & env) {
env. introduce_coop (
// Every agent should work on its own thread.
so_5::disp::active_obj::make_dispatcher ( env ). binder (),
[](so_5:: coop_t & coop) {
auto service_mbox = coop. make_agent < service_provider_t >()
-> so_direct_mbox ();
coop. make_agent < consumer_t >( service_mbox );
} );
} );
}Sobjectizer sendiri dimaksudkan untuk menjadi proyek yang relatif kecil tanpa dependensi eksternal. SO5Extra tidak memiliki kendala ini. Itulah sebabnya dispatcher dan infrastruktur lingkungan yang berbasis ASIO diimplementasikan di SO5Extra, bukan dalam sobjectizer.
Properti penting lainnya dari Sobjectizer adalah stabilitas. Kami mencoba untuk menjaga Sobjectizer setenang mungkin, tetapi ada kebutuhan untuk mencoba beberapa fitur baru, bahkan jika kami belum tahu seberapa sukses dan menuntut mereka. SO5Extra adalah tempat yang baik untuk bereksperimen dengan fitur -fitur baru, beberapa di antaranya dapat dipindahkan ke Sobjectizer dengan waktu.
Jadi, jika Anda tidak menemukan fitur yang bermanfaat di Sobjectizer, mari kita coba lihat SO5Extra. Mungkin sudah ada di sana.
Sobjectizer adalah kerangka kerja pengiriman pesan dalam proses. Itu tidak mendukung aplikasi terdistribusi hanya di luar kotak. Tetapi alat dan perpustakaan eksternal dapat digunakan dalam kasus itu. Harap lihat Eksperimen Mosquitto_Transport kami: https://github.com/STFFSTREAM/MOSQUITTO_TRANSPORT
Sobjectizer dapat diperiksa dari GitHub. Arsip dengan kode sumber Sobjectizer dapat diunduh dari GitHub atau dari SourceForge.
Ada dua cara untuk membangun sobyekizer. Yang pertama dengan menggunakan alat mxx_ru. Yang kedua dengan menggunakan cmake.
CATATAN. Sejak v.5.5.15.2 Ada dukungan dari platform Android. Building for Android dimungkinkan oleh CMake saja. Lihat bagian yang sesuai di bawah ini.
Sobjectizer juga dapat diinstal dan digunakan melalui manajer ketergantungan VCPKG dan Conan . Lihat bagian yang sesuai di bawah ini.
5,8-cabang sobjectizer membutuhkan C ++ 17.
Jika Anda memerlukan dukungan untuk C ++ 14 atau C ++ 11, cobalah untuk melihat ke versi yang lebih lama dari Sobjectizer di SourceForge. Atau hubungi Stiffstream untuk membahas porting sobjectizer-5.8 ke standar C ++ yang lebih lama.
CATATAN. Ini adalah cara standar untuk membangun sobjectizer. Cara ini digunakan dalam proses pengembangan sobjectizer.
Untuk membangun sobjectizer perlu menggunakan bahasa Ruby dan alat mxx_ru. Instal Ruby lalu instal MXX_RU melalui perintah Rubygems:
gem install Mxx_ruJika Anda sudah menginstal MXX_RU, harap perbarui untuk setidaknya versi 1.6.14.6:
gem update Mxx_ruSobjectizer dapat diperoleh dari repositori git di github:
git clone https://github.com/stiffstream/sobjectizerUntuk membangun sobjectizer:
cd sobjectizer/dev
ruby build.rbPerpustakaan statis dan bersama untuk Sobjectizer akan dibangun. Perpustakaan akan ditempatkan ke subdirektori target/rilis.
Jika Anda ingin membangun perpustakaan yang baru saja dibagikan:
cd sobjectizer/dev
ruby so_5/prj.rbAtau jika Anda ingin membangun hanya perpustakaan statis:
cd sobjectizer/dev
ruby so_5/prj_s.rbUntuk membangun sobjeksizer dengan semua tes dan sampel:
cd sobjectizer/dev
ruby build_all.rbHarap dicatat bahwa di bawah freebsd mungkin perlu untuk mendefinisikan variabel lingkungan ld_library_path. Dan urutan perintah build yang sebenarnya di bawah freebsd bisa sebagai berikut:
cd sobjectizer/dev
export LD_LIBRARY_PATH=target/release
ruby build_all.rbUntuk membangun dokumentasi format HTML untuk sobjectizer, alat doxygen diperlukan. Jika diinstal maka:
cd sobjectizer/doxygen
doxygenHTML-Files yang dihasilkan akan berlokasi di Sobjectizer/dev/doc/html.
CATATAN. Jika Anda tidak menentukan mxx_ru_cpp_toolset oleh Anda sendiri maka mxx_ru akan mencoba mendeteksi toolset c ++ Anda secara otomatis. Jika Anda ingin menggunakan kompiler C ++ yang tidak default di sistem Anda, tentukan variabel lingkungan MXX_RU_CPP_TOOLSET secara manual. Itu bisa terlihat seperti:
export MXX_RU_CPP_TOOLSET= " clang_linux compiler_name=clang++-6 linker_name=clang++-6 "Informasi lebih lanjut tentang Tuning MXX_RU untuk kebutuhan Anda yang dapat Anda temukan dalam dokumentasi yang sesuai.
Untuk membangun sobjectizer melalui cmake perlu memiliki cmake dan beberapa pengetahuan tentang cara menggunakannya. Tindakan berikut hanyalah sebuah demonstrasi. Untuk info lebih rinci tentang CMake Build System for Sobjectizer lihat dev/cmake/cmakequickhowto.txt
Untuk mendapatkan dan membangun sobjectizer di bawah linux/freebsd di baris perintah run:
git clone https://github.com/stiffstream/sobjectizer
cd sobjectizer
mkdir cmake_build
cd cmake_build
cmake -DCMAKE_INSTALL_PREFIX=target -DCMAKE_BUILD_TYPE=Release ../dev
cmake --build . --config Release
cmake --build . --config Release --target installPerintah -perintah itu akan membuat semua makefile yang diperlukan, lalu membangun sobjectizer. Jika perlu membangun contoh dan tes juga, gunakan
cmake -DBUILD_ALL=ON -DCMAKE_INSTALL_PREFIX=target ../devSaat 'buat instal' selesai '.
Sistem CMake Build saat ini mendukung opsi ini:
SOBJECTIZER_BUILD_STATIC . Aktifkan Building Sobjectizer sebagai pustaka statis [default: aktif]SOBJECTIZER_BUILD_SHARED . Aktifkan Building Sobjectizer sebagai perpustakaan bersama [default: aktif]BUILD_ALL . Aktifkan contoh bangunan dan tes [default: off]BUILD_EXAMPLES . Aktifkan contoh bangunan [default: off]BUILD_TESTS . Aktifkan Tes Bangunan [Default: OFF] Harap dicatat bahwa jika BUILD_ALL atau BUILD_EXAMPLES atau BUILD_TESTS dihidupkan maka kedua SOBJECTIZER_BUILD_STATIC dan SOBJECTIZER_BUILD_SHARED harus dihidupkan. Ini berarti bahwa jika SOBJECTIZER_BUILD_STATIC atau SOBJECTIZER_BUILD_SHARED dimatikan maka BUILD_ALL / BUILD_EXAMPLES / BUILD_TESTS Semua harus dimatikan.
Untuk membangun sobjectizer di bawah Windows oleh MS Visual Studio 2013 dari baris perintah:
git clone https://github.com/stiffstream/sobjectizer
cd sobjectizer
mkdir cmake_build
cd cmake_build
cmake -DCMAKE_INSTALL_PREFIX=target -DCMAKE_BUILD_TYPE=Release -G " Visual Studio 15 2017 " ../dev
cmake --build . --config Release
cmake --build . --config Release --target install Jika perlu membangun contoh juga, gunakan BUILD_ALL dalam doa cmake:
cmake -DCMAKE_INSTALL_PREFIX=target -DCMAKE_BUILD_TYPE=Release -DBUILD_ALL=ON -G " Visual Studio 15 2017 " ../dev Karena V.5.5.24 Sobjectizer menyediakan file sobjectizer-config.cmake. File -file ini secara otomatis diinstal ke dalam subfolder <target>/lib/cmake/sobjectizer . Ini memungkinkan untuk menggunakan sobjectizer melalui perintah find_package cmake.
Building for Android dimungkinkan melalui NDK Android yang agak segar atau Crystax NDK.
Anda memerlukan Android SDK dan Android NDK yang diinstal di sistem Anda. Serta versi CMake yang sesuai. Anda juga perlu mengatur variabel lingkungan dengan benar ANDROID_HOME , ANDROID_NDK . Maka Anda dapat mengeluarkan perintah berikut:
git clone https://github.com/stiffstream/sobjectizer
cd sobjectizer
mkdir cmake_build
cd cmake_build
cmake -DBUILD_ALL -DCMAKE_INSTALL_PREFIX=target -DCMAKE_BUILD_TYPE=Release
-DCMAKE_TOOLCHAIN_FILE= ${ANDROID_NDK} /build/cmake/android.toolchain.cmake
-G Ninja
-DANDROID_ABI=arm64-v8a
-DANDROID_NDK= ${ANDROID_NDK}
-DANDROID_NATIVE_API_LEVEL=23
-DANDROID_TOOLCHAIN=clang
../dev
cmake --build . --config=Release
cmake --build . --config=Release --target installAnda memerlukan Crystax NDK V.10.4.0 atau lebih tinggi sudah diinstal di sistem Anda. CMake digunakan untuk membangun sobjectizer:
git clone https://github.com/stiffstream/sobjectizer
cd sobjectizer
mkdir cmake_build
cd cmake_build
export NDK=/path/to/the/crystax-ndk
cmake -DBUILD_ALL -DCMAKE_INSTALL_PREFIX=result -DCMAKE_TOOLCHAIN_FILE= $NDK /cmake/toolchain.cmake -DANDROID_ABI=arm64-v8a ../dev
make
make test
make installUntuk menggunakan sobjectizer melalui vcpkg perlu melakukan langkah -langkah berikut.
Instal Paket sobjectizer :
vcpkg install sobjectizerTambahkan baris berikut ke dalam file cmakelists.txt Anda:
find_package (sobjectizer CONFIG REQUIRED)
target_link_libraries (your_target sobjectizer::SharedLib) # or sobjectizer::StaticLibCATATAN. Sejak Februari 2021 versi baru dari Sobjectizer hanya tersedia melalui Conan-Center.
Untuk menggunakan sobjectizer melalui conan, perlu untuk menambahkan sobjectizer ke conanfile.txt proyek Anda:
[requires]
sobjectizer/5.8.0
Mungkin juga perlu untuk menentukan opsi shared untuk sobjectizer. Misalnya, untuk membangun sobjectizer sebagai perpustakaan statis:
[options]
sobjectizer:shared=False
Instal dependensi untuk proyek Anda:
conan install SOME_PATH --build=missing
...
include ( ${CMAKE_BINARY_DIR} /conanbuildinfo.cmake)
conan_basic_setup()
...
target_link_libraries (your_target ${CONAN_LIBS} )Sobjectizer didistribusikan di bawah lisensi BSD 3-klausa. Untuk informasi lisensi, silakan lihat file lisensi.
