Lines Matching full:ssid
43 // Segment Set ID (SSID) is in range [-kMaxSID+1, -1]
259 class SSID: public ID {
261 explicit SSID(T id) : ID(id) {}
262 explicit SSID(SID sid) : ID(sid.raw()) {}
263 SSID(): ID(INT_MAX) {}
396 static uint32_t combine2(SSID a, SID b) {
1986 static NOINLINE SSID AddSegmentToSS(SSID old_ssid, SID new_sid);
1987 static NOINLINE SSID RemoveSegmentFromSS(SSID old_ssid, SID sid_to_remove);
1989 static INLINE SSID AddSegmentToTupleSS(SSID ssid, SID new_sid);
1990 static INLINE SSID RemoveSegmentFromTupleSS(SSID old_ssid, SID sid_to_remove);
1992 SSID ComputeSSID() {
1993 SSID res = map_->GetIdOrZero(this);
2000 static void AssertLive(SSID ssid, int line) {
2001 DCHECK(ssid.valid());
2003 if (ssid.IsSingleton()) {
2004 Segment::AssertLive(ssid.GetSingleton(), line);
2006 DCHECK(ssid.IsTuple());
2007 int idx = -ssid.raw()-1;
2016 Printf("SegmentSet::AssertLive failed at line %d (ssid=%d)\n",
2017 line, ssid.raw());
2024 static SegmentSet *Get(SSID ssid) {
2025 DCHECK(ssid.valid());
2026 DCHECK(!ssid.IsSingleton());
2027 int idx = -ssid.raw()-1;
2037 void RecycleOneSegmentSet(SSID ssid) {
2039 DCHECK(ssid.valid());
2040 DCHECK(!ssid.IsSingleton());
2041 int idx = -ssid.raw()-1;
2044 // Printf("SegmentSet::RecycleOneSegmentSet: %d\n", ssid.raw());
2055 ready_to_be_reused_->push_back(ssid);
2059 static void INLINE Ref(SSID ssid, const char *where) {
2060 DCHECK(ssid.valid());
2061 if (ssid.IsSingleton()) {
2062 Segment::Ref(ssid.GetSingleton(), where);
2064 SegmentSet *sset = Get(ssid);
2065 // Printf("SSRef : %d ref=%d %s\n", ssid.raw(), sset->ref_count_, where);
2071 static void INLINE Unref(SSID ssid, const char *where) {
2072 DCHECK(ssid.valid());
2073 if (ssid.IsSingleton()) {
2074 Segment::Unref(ssid.GetSingleton(), where);
2076 SegmentSet *sset = Get(ssid);
2077 // Printf("SSUnref : %d ref=%d %s\n", ssid.raw(), sset->ref_count_, where);
2081 // We don't delete unused SSID straightaway due to performance reasons
2082 // (to avoid flushing caches too often and because SSID may be reused
2088 // 1) When refcount_ becomes zero, we push the SSID into
2093 // ready_to_be_recycled_ and for each popped SSID we do
2094 // * if "refcount_ > 0", do nothing (this SSID is in use again)
2095 // * otherwise, we recycle this SSID (delete its VTS, etc) and push
2097 // 3) When a new SegmentSet is about to be created, we re-use SSID from
2099 ready_to_be_recycled_->push_back(ssid);
2111 SSID rec_ssid = ready_to_be_recycled_->front();
2117 // We should check that this SSID haven't been referenced again.
2132 static string ToString(SSID ssid) {
2133 CHECK(ssid.IsValidOrEmpty());
2134 if (ssid.IsSingleton()) {
2135 return "{" + Segment::ToStringTidOnly(SID(ssid.raw())) + "}";
2136 } else if (ssid.IsEmpty()) {
2139 AssertLive(ssid, __LINE__);
2140 return Get(ssid)->ToString();
2145 static string ToStringWithLocks(SSID ssid);
2166 static int32_t Size(SSID ssid) {
2167 if (ssid.IsEmpty()) return 0;
2168 if (ssid.IsSingleton()) return 1;
2169 return Get(ssid)->size();
2184 static SID GetSID(SSID ssid, int32_t i, int line) {
2185 DCHECK(ssid.valid());
2186 if (ssid.IsSingleton()) {
2188 Segment::AssertLive(ssid.GetSingleton(), line);
2189 return ssid.GetSingleton();
2191 AssertLive(ssid, __LINE__);
2192 SID sid = Get(ssid)->GetSID(i);
2198 static bool INLINE Contains(SSID ssid, SID seg) {
2199 if (LIKELY(ssid.IsSingleton())) {
2200 return ssid.GetSingleton() == seg;
2201 } else if (LIKELY(ssid.IsEmpty())) {
2205 SegmentSet *ss = Get(ssid);
2215 static Segment *GetSegmentForNonSingleton(SSID ssid, int32_t i, int line) {
2216 return Segment::Get(GetSID(ssid, i, line));
2227 ready_to_be_recycled_ = new deque<SSID>;
2228 ready_to_be_reused_ = new deque<SSID>;
2253 static INLINE SSID AllocateAndCopy(SegmentSet *ss) {
2256 SSID res_ssid;
2276 res_ssid = SSID(-((int32_t)vec_->size()));
2292 static NOINLINE SSID FindExistingOrAlocateAndCopy(SegmentSet *ss) {
2302 SSID ssid = map_->GetIdOrZero(ss);
2303 if (ssid.raw() != 0) { // Found.
2304 AssertLive(ssid, __LINE__);
2306 return ssid;
2312 static INLINE SSID DoubletonSSID(SID sid1, SID sid2) {
2321 SSID ssid = AddSegmentToTupleSS(ss->ComputeSSID(), new_sid);
2322 AssertLive(ssid, __LINE__);
2323 return Get(ssid);
2327 SSID ssid = DoubletonSSID(sid1, sid2);
2328 ssid, __LINE__);
2329 return Get(ssid);
2397 static SSID GetIdOrZeroFromMap(MapType *map, SegmentSet *ss) {
2400 return SSID(0);
2406 SSID GetIdOrZero(SegmentSet *ss) {
2410 void Insert(SegmentSet *ss, SSID id) {
2425 typedef stdext::hash_map<SegmentSet*, SSID, SSTraits > MapType__;
2427 typedef unordered_map<SegmentSet*, SSID, SSHash, SSEq > MapType__;
2430 typedef map<SegmentSet*, SSID, Less > MapType__;
2435 // typedef map<SegmentSet*, SSID, Less> Map;
2440 static deque<SSID> *ready_to_be_reused_;
2441 static deque<SSID> *ready_to_be_recycled_;
2443 typedef PairCache<SSID, SID, SSID, 1009, 1> SsidSidToSidCache;
2455 deque<SSID> *SegmentSet::ready_to_be_reused_;
2456 deque<SSID> *SegmentSet::ready_to_be_recycled_;
2463 SSID SegmentSet::RemoveSegmentFromSS(SSID old_ssid, SID sid_to_remove) {
2466 SSID res;
2476 res = SSID(0); // Empty.
2489 // This method returns a SSID of a SegmentSet containing "new_sid" and all those
2494 SSID SegmentSet::AddSegmentToSS(SSID old_ssid, SID new_sid) {
2498 SSID res;
2518 return SSID(new_sid);
2524 return SSID(new_sid);
2530 return SSID(new_sid);
2565 SSID SegmentSet::RemoveSegmentFromTupleSS(SSID ssid, SID sid_to_remove) {
2566 DCHECK(ssid.IsTuple());
2567 DCHECK(ssid.valid());
2568 AssertLive(ssid, __LINE__);
2569 SegmentSet *ss = Get(ssid);
2586 if (new_size == old_size) return ssid;
2587 if (new_size == 0) return SSID(0);
2588 if (new_size == 1) return SSID(tmp_sids[0]);
2592 SSID res = FindExistingOrAlocateAndCopy(&tmp);
2598 SSID SegmentSet::AddSegmentToTupleSS(SSID ssid, SID new_sid) {
2599 DCHECK(ssid.IsTuple());
2600 DCHECK(ssid.valid());
2601 AssertLive(ssid, __LINE__);
2602 SegmentSet *ss = Get(ssid);
2624 return ssid;
2634 return ssid;
2660 return SSID(new_sid.raw()); // Singleton.
2694 SSID res = FindExistingOrAlocateAndCopy(&tmp);
2735 string SegmentSet::ToStringWithLocks(SSID ssid) {
2736 if (ssid.IsEmpty()) return "";
2738 for (int i = 0; i < Size(ssid); i++) {
2739 SID sid = GetSID(ssid, i, __LINE__);
2797 SSID ssid6 = SegmentSet::AddSegmentToTupleSS(d4->ComputeSSID(), sid6);
2821 SSID rd_ssid() const { return SSID(rd_ssid_); }
2822 SSID wr_ssid() const { return SSID(wr_ssid_); }
2823 INLINE void set(SSID rd_ssid, SSID wr_ssid) {
3480 set <SSID> all_ssids;
3484 SSID ssid = i ? sval.rd_ssid() : sval.wr_ssid();
3485 all_ssids.insert(ssid);
3490 for (set<SSID>::iterator it = all_ssids.begin(); it != all_ssids.end(); ++it) {
5629 void AnnounceThreadsInSegmentSet(SSID ssid) {
5630 if (ssid.IsEmpty()) return;
5631 for (int s = 0; s < SegmentSet::Size(ssid); s++) {
5632 Segment *seg = SegmentSet::GetSegmentForNonSingleton(ssid, s, __LINE__);
5639 void PrintConcurrentSegmentSet(SSID ssid, TID tid, SID sid,
5643 if (ssid.IsEmpty()) return;
5646 for (int s = 0; s < SegmentSet::Size(ssid); s++) {
5647 SID concurrent_sid = SegmentSet::GetSID(ssid, s, __LINE__);
6727 INLINE void RefAndUnrefTwoSegSetPairsIfDifferent(SSID new_ssid1,
6728 SSID old_ssid1,
6729 SSID new_ssid2,
6730 SSID old_ssid2) {
6753 bool NOINLINE CheckIfRace(SSID rd_ssid, SSID wr_ssid) {
6808 new_sval.set(SSID(0), SSID(cur_sid));
6810 new_sval.set(SSID(cur_sid), SSID(0));
6816 SSID old_rd_ssid = old_sval.rd_ssid();
6817 SSID old_wr_ssid = old_sval.wr_ssid();
6818 SSID new_rd_ssid(0);
6819 SSID new_wr_ssid(0);
6864 SSID rd_ssid = old_sval.rd_ssid();
6865 SSID wr_ssid = old_sval.wr_ssid();
6882 new_sval->set(SSID(0), SSID(cur_sid));
6886 new_sval->set(SSID(cur_sid), wr_ssid);
6895 new_sval->set(SSID(0), SSID(cur_sid));
6898 new_sval->set(SSID(cur_sid), SSID(0));
6911 new_sval->set(SSID(0), SSID(cur_sid));
6923 new_sval->set(SSID(0), SSID(cur_sid));
6926 new_sval->set(SSID(cur_sid), SSID(0));
6941 new_sval->set(SSID(0), SSID(cur_sid));
6956 new_sval->set(SSID(0), SSID(cur_sid));
6965 new_sval->set(SSID(0), SSID(cur_sid));
6969 new_sval->set(SSID(cur_sid), wr_ssid);
7044 SSID ssid = i ? sval_p->rd_ssid() : sval_p->wr_ssid();
7045 if (ssid.IsEmpty()) continue;
7046 if (ssid.IsSingleton()) {
7048 SID sid = ssid.GetSingleton();
7056 SegmentSet *sset = SegmentSet::Get(ssid);
