int PixmapCacheModel::updateCacheCount(int lastCacheSizeEvent, qint64 pixmapStartTime, qint64 pixSize, PixmapCacheItem &newEvent, int typeId) { newEvent.pixmapEventType = PixmapCacheCountChanged; newEvent.rowNumberCollapsed = 1; newEvent.typeId = typeId; int index = lastCacheSizeEvent; if (lastCacheSizeEvent != -1) { newEvent.cacheSize = m_data[lastCacheSizeEvent].cacheSize + pixSize; qint64 duration = pixmapStartTime - startTime(lastCacheSizeEvent); if (duration > 0) { insertEnd(lastCacheSizeEvent, duration); index = insertStart(pixmapStartTime, 0); m_data.insert(index, newEvent); } else { // If the timestamps are the same, just replace it m_data[index] = newEvent; } } else { newEvent.cacheSize = pixSize; index = insertStart(pixmapStartTime, 0); m_data.insert(index, newEvent); } return index; }
void QmlProfilerRangeModel::loadEvent(const QmlEvent &event, const QmlEventType &type) { Q_UNUSED(type); // store starttime-based instance if (event.rangeStage() == RangeStart) { int index = insertStart(event.timestamp(), event.typeIndex()); m_stack.append(index); m_data.insert(index, QmlRangeEventStartInstance()); } else if (event.rangeStage() == RangeEnd) { if (!m_stack.isEmpty()) { int index = m_stack.pop(); insertEnd(index, event.timestamp() - startTime(index)); } else { qWarning() << "Received inconsistent trace data from application."; } } }
/* Ultimately there is no way to know which cache entry a given event refers to as long as we only * receive the pixmap URL from the application. Multiple copies of different sizes may be cached * for each URL. However, we can apply some heuristics to make the result somewhat plausible by * using the following assumptions: * * - PixmapSizeKnown will happen at most once for every cache entry. * - PixmapSizeKnown cannot happen for entries with PixmapLoadingError and vice versa. * - PixmapCacheCountChanged can happen for entries with PixmapLoadingError but doesn't have to. * - Decreasing PixmapCacheCountChanged events can only happen for entries that have seen an * increasing PixmapCacheCountChanged (but that may have happened before the trace). * - PixmapCacheCountChanged can happen before or after PixmapSizeKnown. * - For every PixmapLoadingFinished or PixmapLoadingError there is exactly one * PixmapLoadingStarted event, but it may be before the trace. * - For every PixmapLoadingStarted there is exactly one PixmapLoadingFinished or * PixmapLoadingError, but it may be after the trace. * - Decreasing PixmapCacheCountChanged events in the presence of corrupt cache entries are more * likely to clear those entries than other, correctly loaded ones. * - Increasing PixmapCacheCountChanged events are more likely to refer to correctly loaded entries * than to ones with PixmapLoadingError. * - PixmapLoadingFinished and PixmapLoadingError are more likely to refer to cache entries that * have seen a PixmapLoadingStarted than to ones that haven't. * * For each URL we keep an ordered list of pixmaps possibly being loaded and assign new events to * the first entry that "fits". If multiple sizes of the same pixmap are being loaded concurrently * we generally assume that the PixmapLoadingFinished and PixmapLoadingError events occur in the * order we learn about the existence of these sizes, subject to the above constraints. This is not * necessarily the order the pixmaps are really loaded but it's the best we can do with the given * information. If they're loaded sequentially the representation is correct. */ void PixmapCacheModel::loadEvent(const QmlEvent &event, const QmlEventType &type) { PixmapCacheItem newEvent; const PixmapEventType pixmapType = static_cast<PixmapEventType>(type.detailType()); newEvent.pixmapEventType = pixmapType; qint64 pixmapStartTime = event.timestamp(); newEvent.urlIndex = -1; for (auto i = m_pixmaps.cend(), begin = m_pixmaps.cbegin(); i != begin;) { if ((--i)->url == type.location().filename()) { newEvent.urlIndex = i - m_pixmaps.cbegin(); break; } } newEvent.sizeIndex = -1; if (newEvent.urlIndex == -1) { newEvent.urlIndex = m_pixmaps.count(); m_pixmaps << Pixmap(type.location().filename()); } Pixmap &pixmap = m_pixmaps[newEvent.urlIndex]; switch (pixmapType) { case PixmapSizeKnown: {// pixmap size // Look for pixmaps for which we don't know the size, yet and which have actually been // loaded. for (auto i = pixmap.sizes.begin(), end = pixmap.sizes.end(); i != end; ++i) { if (i->size.isValid() || i->cacheState == Uncacheable || i->cacheState == Corrupt) continue; // We can't have cached it before we knew the size Q_ASSERT(i->cacheState != Cached); i->size.setWidth(event.number<qint32>(0)); i->size.setHeight(event.number<qint32>(1)); newEvent.sizeIndex = i - pixmap.sizes.begin(); break; } if (newEvent.sizeIndex == -1) { newEvent.sizeIndex = pixmap.sizes.length(); pixmap.sizes << PixmapState(event.number<qint32>(0), event.number<qint32>(1)); } PixmapState &state = pixmap.sizes[newEvent.sizeIndex]; if (state.cacheState == ToBeCached) { m_lastCacheSizeEvent = updateCacheCount(m_lastCacheSizeEvent, pixmapStartTime, state.size.width() * state.size.height(), newEvent, event.typeIndex()); state.cacheState = Cached; } break; } case PixmapCacheCountChanged: {// Cache Size Changed Event bool uncache = m_cumulatedCount > event.number<qint32>(2); m_cumulatedCount = event.number<qint32>(2); qint64 pixSize = 0; // First try to find a preferred pixmap, which either is Corrupt and will be uncached // or is uncached and will be cached. for (auto i = pixmap.sizes.begin(), end = pixmap.sizes.end(); i != end; ++i) { if (uncache && i->cacheState == Corrupt) { newEvent.sizeIndex = i - pixmap.sizes.begin(); i->cacheState = Uncacheable; break; } else if (!uncache && i->cacheState == Uncached) { newEvent.sizeIndex = i - pixmap.sizes.begin(); if (i->size.isValid()) { pixSize = i->size.width() * i->size.height(); i->cacheState = Cached; } else { i->cacheState = ToBeCached; } break; } } // If none found, check for cached or ToBeCached pixmaps that shall be uncached or // Error pixmaps that become corrupt cache entries. We also accept Initial to be // uncached as we may have missed the matching PixmapCacheCountChanged that cached it. if (newEvent.sizeIndex == -1) { for (auto i = pixmap.sizes.begin(), end = pixmap.sizes.end(); i != end; ++i) { if (uncache && (i->cacheState == Cached || i->cacheState == ToBeCached)) { newEvent.sizeIndex = i - pixmap.sizes.begin(); if (i->size.isValid()) pixSize = -i->size.width() * i->size.height(); i->cacheState = Uncached; break; } else if (!uncache && i->cacheState == Uncacheable) { // A pixmap can repeatedly be cached, become corrupt, and the be uncached again. newEvent.sizeIndex = i - pixmap.sizes.begin(); i->cacheState = Corrupt; break; } } } // If that does't work, create a new entry. if (newEvent.sizeIndex == -1) { newEvent.sizeIndex = pixmap.sizes.length(); pixmap.sizes << PixmapState(uncache ? Uncached : ToBeCached); // now the size is 0. Thus, there is no point in updating the size row. } else if (pixSize != 0) { m_lastCacheSizeEvent = updateCacheCount(m_lastCacheSizeEvent, pixmapStartTime, pixSize, newEvent, event.typeIndex()); } break; } case PixmapLoadingStarted: { // Load // Look for a pixmap that hasn't been started, yet. There may have been a refcount // event, which we ignore. for (auto i = pixmap.sizes.cbegin(), end = pixmap.sizes.cend(); i != end; ++i) { if (i->loadState == Initial) { newEvent.sizeIndex = i - pixmap.sizes.cbegin(); break; } } if (newEvent.sizeIndex == -1) { newEvent.sizeIndex = pixmap.sizes.length(); pixmap.sizes << PixmapState(); } PixmapState &state = pixmap.sizes[newEvent.sizeIndex]; state.loadState = Loading; newEvent.typeId = event.typeIndex(); state.started = insertStart(pixmapStartTime, newEvent.urlIndex + 1); m_data.insert(state.started, newEvent); break; } case PixmapLoadingFinished: case PixmapLoadingError: { // First try to find one that has already started for (auto i = pixmap.sizes.cbegin(), end = pixmap.sizes.cend(); i != end; ++i) { if (i->loadState != Loading) continue; // Pixmaps with known size cannot be errors and vice versa if (pixmapType == PixmapLoadingError && i->size.isValid()) continue; newEvent.sizeIndex = i - pixmap.sizes.cbegin(); break; } // If none was found use any other compatible one if (newEvent.sizeIndex == -1) { for (auto i = pixmap.sizes.cbegin(), end = pixmap.sizes.cend(); i != end; ++i) { if (i->loadState != Initial) continue; // Pixmaps with known size cannot be errors and vice versa if (pixmapType == PixmapLoadingError && i->size.isValid()) continue; newEvent.sizeIndex = i - pixmap.sizes.cbegin(); break; } } // If again none was found, create one. if (newEvent.sizeIndex == -1) { newEvent.sizeIndex = pixmap.sizes.length(); pixmap.sizes << PixmapState(); } PixmapState &state = pixmap.sizes[newEvent.sizeIndex]; // If the pixmap loading wasn't started, start it at traceStartTime() if (state.loadState == Initial) { newEvent.pixmapEventType = PixmapLoadingStarted; newEvent.typeId = event.typeIndex(); qint64 traceStart = modelManager()->traceTime()->startTime(); state.started = insert(traceStart, pixmapStartTime - traceStart, newEvent.urlIndex + 1); m_data.insert(state.started, newEvent); // All other indices are wrong now as we've prepended. Fix them ... if (m_lastCacheSizeEvent >= state.started) ++m_lastCacheSizeEvent; for (int pixmapIndex = 0; pixmapIndex < m_pixmaps.count(); ++pixmapIndex) { Pixmap &brokenPixmap = m_pixmaps[pixmapIndex]; for (int sizeIndex = 0; sizeIndex < brokenPixmap.sizes.count(); ++sizeIndex) { PixmapState &brokenSize = brokenPixmap.sizes[sizeIndex]; if ((pixmapIndex != newEvent.urlIndex || sizeIndex != newEvent.sizeIndex) && brokenSize.started >= state.started) { ++brokenSize.started; } } } } else { insertEnd(state.started, pixmapStartTime - startTime(state.started)); } if (pixmapType == PixmapLoadingError) { state.loadState = Error; switch (state.cacheState) { case Uncached: state.cacheState = Uncacheable; break; case ToBeCached: state.cacheState = Corrupt; break; default: // Cached cannot happen as size would have to be known and Corrupt or // Uncacheable cannot happen as we only accept one finish or error event per // pixmap. Q_UNREACHABLE(); } } else { state.loadState = Finished; } break; } default: break; } }
int main() { char ch , a='y'; int choice, c, token; printf("Enter your choice for which deque operation you want to perform operation \n"); do { printf("\n1.Input-restricted deque \n"); printf("2.output-restricted deque \n"); printf("\nEnter your choice for the operation : "); scanf("%d",&c); switch(c) { case 1: printf("\nDo operation in Input-Restricted c deque\n"); printf("1.Insert"); printf("\n2.Delete from end"); printf("\n3.Delete from begning"); printf("\n4.show or display"); do { printf("\nEnter your choice for the operation in c deque: "); scanf("%d",&choice); switch(choice) { case 1: insertEnd(token); display(); break; case 2: token=delEnd(); printf("\nThe token deleted is %d",token); display(); break; case 3: token=delStart(); printf("\nThe token deleted is %d",token); display(); break; case 4: display(); break; default:printf("Wrong choice"); break; } printf("\nDo you want to continue(y/n) to do operation in input-restricted c deque: "); ch=getch(); } while(ch=='y'||ch=='Y'); getch(); break; case 2 : printf("\nDo operation in Output-Restricted c deque\n"); printf("1.Insert at the End"); printf("\n2.Insert at the begning"); printf("\n3.Delete the element"); printf("\n4.show or display"); do { printf("\nEnter your choice for the operation: "); scanf("%d",&choice); switch(choice) { case 1: insertEnd(token); display(); break; case 2: insertStart(token); display(); break; case 3: token=delStart(); printf("\nThe token deleted is %d",token); display(); break; case 4: display(); break; default:printf("Wrong choice"); break; } printf("\nDo you want to continue(y/n):"); ch=getch(); } while(ch=='y'||ch=='Y'); getch(); break ; } printf("\nDo you want to continue(y/n):"); ch=getch(); } while(ch=='y'||ch=='Y'); getch(); }