diff --git a/trunk/conf/full.conf b/trunk/conf/full.conf index d90840c19..957fcdff5 100644 --- a/trunk/conf/full.conf +++ b/trunk/conf/full.conf @@ -503,11 +503,11 @@ rtc_server { # default: off enabled off; # The cache size for rtp packet in MB, each object is about 300B.. - # default: 128 - pkt_size 128.0; + # default: 64 + pkt_size 64.0; # The cache size for rtp payload in MB, each object is about 40B. - # default: 32 - payload_size 32.0; + # default: 16 + payload_size 16.0; } # For RTP shared message and the large buffer cache. rtp_msg_cache { @@ -515,11 +515,11 @@ rtc_server { # default: off enabled off; # The cache size for message object in MB, each object is about 40B. - # default: 32 - msg_size 32.0; + # default: 16 + msg_size 16.0; # The cache size for message large buffer in MB, each object is about 1500B. - # default: 1024 - buffer_size 1024.0; + # default: 512 + buffer_size 512.0; } # The black-hole to copy packet to, for debugging. # For example, when debugging Chrome publish stream, the received packets are encrypted cipher, diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp index c30cf679e..4d6771bf0 100644 --- a/trunk/src/app/srs_app_config.cpp +++ b/trunk/src/app/srs_app_config.cpp @@ -4936,7 +4936,7 @@ bool SrsConfig::get_rtc_server_rtp_cache_enabled() uint64_t SrsConfig::get_rtc_server_rtp_cache_pkt_size() { - int DEFAULT = 128 * 1024 * 1024; + int DEFAULT = 64 * 1024 * 1024; SrsConfDirective* conf = get_rtc_server_rtp_cache(); if (!conf) { @@ -4948,12 +4948,12 @@ uint64_t SrsConfig::get_rtc_server_rtp_cache_pkt_size() return DEFAULT; } - return (uint64_t)(1024 * ::atof(conf->arg0().c_str())); + return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str())); } uint64_t SrsConfig::get_rtc_server_rtp_cache_payload_size() { - int DEFAULT = 32 * 1024 * 1024; + int DEFAULT = 16 * 1024 * 1024; SrsConfDirective* conf = get_rtc_server_rtp_cache(); if (!conf) { @@ -4965,7 +4965,7 @@ uint64_t SrsConfig::get_rtc_server_rtp_cache_payload_size() return DEFAULT; } - return (uint64_t)(1024 * ::atof(conf->arg0().c_str())); + return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str())); } SrsConfDirective* SrsConfig::get_rtc_server_rtp_msg_cache() @@ -5002,7 +5002,7 @@ bool SrsConfig::get_rtc_server_rtp_msg_cache_enabled() uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_msg_size() { - int DEFAULT = 32 * 1024 * 1024; + int DEFAULT = 16 * 1024 * 1024; SrsConfDirective* conf = get_rtc_server_rtp_msg_cache(); if (!conf) { @@ -5014,12 +5014,12 @@ uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_msg_size() return DEFAULT; } - return (uint64_t)(1024 * ::atof(conf->arg0().c_str())); + return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str())); } uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_buffer_size() { - int DEFAULT = 1024 * 1024 * 1024; + int DEFAULT = 512 * 1024 * 1024; SrsConfDirective* conf = get_rtc_server_rtp_msg_cache(); if (!conf) { @@ -5031,7 +5031,7 @@ uint64_t SrsConfig::get_rtc_server_rtp_msg_cache_buffer_size() return DEFAULT; } - return (uint64_t)(1024 * ::atof(conf->arg0().c_str())); + return 1024 * (uint64_t)(1024 * ::atof(conf->arg0().c_str())); } bool SrsConfig::get_rtc_server_black_hole() diff --git a/trunk/src/app/srs_app_rtc_server.cpp b/trunk/src/app/srs_app_rtc_server.cpp index b2bad7285..9dbb9342b 100644 --- a/trunk/src/app/srs_app_rtc_server.cpp +++ b/trunk/src/app/srs_app_rtc_server.cpp @@ -282,17 +282,17 @@ srs_error_t SrsRtcServer::initialize() bool rtp_cache_enabled = _srs_config->get_rtc_server_rtp_cache_enabled(); uint64_t rtp_cache_pkt_size = _srs_config->get_rtc_server_rtp_cache_pkt_size(); uint64_t rtp_cache_payload_size = _srs_config->get_rtc_server_rtp_cache_payload_size(); - _srs_rtp_cache->set_enabled(rtp_cache_enabled, rtp_cache_pkt_size); - _srs_rtp_raw_cache->set_enabled(rtp_cache_enabled, rtp_cache_payload_size); - _srs_rtp_fua_cache->set_enabled(rtp_cache_enabled, rtp_cache_payload_size); + _srs_rtp_cache->setup(rtp_cache_enabled, rtp_cache_pkt_size); + _srs_rtp_raw_cache->setup(rtp_cache_enabled, rtp_cache_payload_size); + _srs_rtp_fua_cache->setup(rtp_cache_enabled, rtp_cache_payload_size); bool rtp_msg_cache_enabled = _srs_config->get_rtc_server_rtp_msg_cache_enabled(); uint64_t rtp_msg_cache_msg_size = _srs_config->get_rtc_server_rtp_msg_cache_msg_size(); uint64_t rtp_msg_cache_buffer_size = _srs_config->get_rtc_server_rtp_msg_cache_buffer_size(); - _srs_rtp_msg_cache_buffers->set_enabled(rtp_msg_cache_enabled, rtp_msg_cache_msg_size); - _srs_rtp_msg_cache_objs->set_enabled(rtp_msg_cache_enabled, rtp_msg_cache_buffer_size); + _srs_rtp_msg_cache_buffers->setup(rtp_msg_cache_enabled, rtp_msg_cache_buffer_size); + _srs_rtp_msg_cache_objs->setup(rtp_msg_cache_enabled, rtp_msg_cache_msg_size); - srs_trace("RTC server init ok, rtp-cache=(enabled:%d,pkt:%dm-%dw,payload:%dm-%dw-%dw), msg-cache=(enabled:%d,obj:%dm-%dw,buf:%dm-%dw)", + srs_trace("RTC: Object cache init, rtp-cache=(enabled:%d,pkt:%dm-%dw,payload:%dm-%dw-%dw), msg-cache=(enabled:%d,obj:%dm-%dw,buf:%dm-%dw)", rtp_cache_enabled, (int)(rtp_cache_pkt_size/1024/1024), _srs_rtp_cache->capacity()/10000, (int)(rtp_cache_payload_size/1024/1024), _srs_rtp_raw_cache->capacity()/10000, _srs_rtp_fua_cache->capacity()/10000, rtp_msg_cache_enabled, (int)(rtp_msg_cache_msg_size/1024/1024), _srs_rtp_msg_cache_objs->capacity()/10000, diff --git a/trunk/src/app/srs_app_rtc_server.hpp b/trunk/src/app/srs_app_rtc_server.hpp index 8dd4b5530..5ec4efbe5 100644 --- a/trunk/src/app/srs_app_rtc_server.hpp +++ b/trunk/src/app/srs_app_rtc_server.hpp @@ -97,6 +97,7 @@ public: virtual ~SrsRtcServer(); public: virtual srs_error_t initialize(); +public: // Set the handler for server events. void set_handler(ISrsRtcServerHandler* h); void set_hijacker(ISrsRtcServerHijacker* h); diff --git a/trunk/src/kernel/srs_kernel_rtc_rtp.cpp b/trunk/src/kernel/srs_kernel_rtc_rtp.cpp index 4d3b7271a..5b6bcab7f 100644 --- a/trunk/src/kernel/srs_kernel_rtc_rtp.cpp +++ b/trunk/src/kernel/srs_kernel_rtc_rtp.cpp @@ -826,16 +826,20 @@ SrsRtpPacket2::~SrsRtpPacket2() void SrsRtpPacket2::reuse() { - // Only recycle some common payloads. - SrsRtpRawPayload* raw_payload; - SrsRtpFUAPayload2* fua_payload; + if (_srs_rtp_raw_cache->enabled() || _srs_rtp_fua_cache->enabled()) { + // Only recycle some common payloads. + SrsRtpRawPayload* raw_payload; + SrsRtpFUAPayload2* fua_payload; - if ((raw_payload = dynamic_cast(payload)) != NULL) { - _srs_rtp_raw_cache->recycle(raw_payload); - payload = NULL; - } else if ((fua_payload = dynamic_cast(payload)) != NULL) { - _srs_rtp_fua_cache->recycle(fua_payload); - payload = NULL; + if ((raw_payload = dynamic_cast(payload)) != NULL) { + _srs_rtp_raw_cache->recycle(raw_payload); + payload = NULL; + } else if ((fua_payload = dynamic_cast(payload)) != NULL) { + _srs_rtp_fua_cache->recycle(fua_payload); + payload = NULL; + } else { + srs_freep(payload); + } } else { srs_freep(payload); } @@ -850,15 +854,19 @@ void SrsRtpPacket2::reuse_shared_msg() return; } - // We only recycle the RTC UDP packet messages. - if (shared_msg->payload && shared_msg->size == kRtpPacketSize && shared_msg->count() == 0) { - _srs_rtp_msg_cache_buffers->recycle(shared_msg); - } else { - shared_msg->unwrap(); - _srs_rtp_msg_cache_objs->recycle(shared_msg); - } + if (_srs_rtp_msg_cache_buffers->enabled() || _srs_rtp_msg_cache_objs->enabled()) { + // We only recycle the RTC UDP packet messages. + if (shared_msg->payload && shared_msg->size == kRtpPacketSize && shared_msg->count() == 0) { + _srs_rtp_msg_cache_buffers->recycle(shared_msg); + } else { + shared_msg->unwrap(); + _srs_rtp_msg_cache_objs->recycle(shared_msg); + } - shared_msg = NULL; + shared_msg = NULL; + } else { + srs_freep(shared_msg); + } } bool SrsRtpPacket2::reset() @@ -1047,12 +1055,12 @@ srs_error_t SrsRtpPacket2::decode(SrsBuffer* buf) return err; } -SrsRtpObjectCacheManager* _srs_rtp_cache = new SrsRtpObjectCacheManager(); -SrsRtpObjectCacheManager* _srs_rtp_raw_cache = new SrsRtpObjectCacheManager(); -SrsRtpObjectCacheManager* _srs_rtp_fua_cache = new SrsRtpObjectCacheManager(); +SrsRtpObjectCacheManager* _srs_rtp_cache = new SrsRtpObjectCacheManager(sizeof(SrsRtpPacket2)); +SrsRtpObjectCacheManager* _srs_rtp_raw_cache = new SrsRtpObjectCacheManager(sizeof(SrsRtpRawPayload)); +SrsRtpObjectCacheManager* _srs_rtp_fua_cache = new SrsRtpObjectCacheManager(sizeof(SrsRtpFUAPayload2)); -SrsRtpObjectCacheManager* _srs_rtp_msg_cache_buffers = new SrsRtpObjectCacheManager(); -SrsRtpObjectCacheManager* _srs_rtp_msg_cache_objs = new SrsRtpObjectCacheManager(); +SrsRtpObjectCacheManager* _srs_rtp_msg_cache_buffers = new SrsRtpObjectCacheManager(sizeof(SrsSharedPtrMessage) + kRtpPacketSize); +SrsRtpObjectCacheManager* _srs_rtp_msg_cache_objs = new SrsRtpObjectCacheManager(sizeof(SrsSharedPtrMessage)); SrsRtpRawPayload::SrsRtpRawPayload() { diff --git a/trunk/src/kernel/srs_kernel_rtc_rtp.hpp b/trunk/src/kernel/srs_kernel_rtc_rtp.hpp index 77366e714..652128c88 100644 --- a/trunk/src/kernel/srs_kernel_rtc_rtp.hpp +++ b/trunk/src/kernel/srs_kernel_rtc_rtp.hpp @@ -345,10 +345,12 @@ private: bool enabled_; std::list cache_objs_; size_t capacity_; + size_t object_size_; public: - SrsRtpObjectCacheManager() { + SrsRtpObjectCacheManager(size_t size_of_object) { enabled_ = false; capacity_ = 0; + object_size_ = size_of_object; } virtual ~SrsRtpObjectCacheManager() { typedef typename std::list::iterator iterator; @@ -358,11 +360,24 @@ public: } } public: - // Enable or disable cache. - void set_enabled(bool v, uint64_t memory) { + // Setup the object cache, shrink if capacity changed. + void setup(bool v, uint64_t memory) { enabled_ = v; - capacity_ = (size_t)(memory / sizeof(T)); + capacity_ = (size_t)(memory / object_size_); + + + if (!enabled_) { + capacity_ = 0; + } + + // Shrink the cache. + while (cache_objs_.size() > capacity_) { + T* obj = cache_objs_.back(); + cache_objs_.pop_back(); + srs_freep(obj); + } } + // Get the status of object cache. bool enabled() { return enabled_; }