内存管理-50-可读性-1-page_flags.h - Hello

news/2025/11/5 21:57:33/文章来源:https://www.cnblogs.com/hellokitty2/p/19194732

内存管理-50-可读性-1-page_flags.h

基于msm-5.4

实现下面 test.c, 然后 gcc -E test.c -o pp.c 然后得到 page_flags_my.h
#define CONFIG_MMU
#define CONFIG_SWAP

//#define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e))))
#define BUILD_BUG_ON_INVALID(e)
#define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond)

#include "page_flags.h"

page_flags_my.h：

 

enum pageflags {PG_locked,PG_referenced,PG_uptodate,PG_dirty,PG_lru,PG_active,PG_workingset,PG_waiters,PG_error,PG_slab,PG_owner_priv_1,PG_arch_1,PG_reserved,PG_private,PG_private_2,PG_writeback,PG_head,PG_mappedtodisk,PG_reclaim,PG_swapbacked,PG_unevictable,PG_mlocked,__NR_PAGEFLAGS,PG_checked = PG_owner_priv_1,PG_swapcache = PG_owner_priv_1,PG_fscache = PG_private_2,PG_pinned = PG_owner_priv_1,PG_savepinned = PG_dirty,PG_foreign = PG_owner_priv_1,PG_xen_remapped = PG_owner_priv_1,PG_slob_free = PG_private,PG_double_map = PG_private_2,PG_isolated = PG_reclaim,
};struct page;static inline struct page *compound_head(struct page *page)
{unsigned long head = READ_ONCE(page->compound_head);if (unlikely(head & 1))return (struct page *) (head - 1);return page;
}static __always_inline int PageTail(struct page *page)
{return READ_ONCE(page->compound_head) & 1;
}static __always_inline int PageCompound(struct page *page)
{return test_bit(PG_head, &page->flags) || PageTail(page);
}static inline int PagePoisoned(const struct page *page)
{return page->flags == -1l;
}static inline void page_init_poison(struct page *page, size_t size)
{
}static __always_inline int PageLocked(struct page *page)
{return test_bit(PG_locked, &compound_head(page)->flags);
}static __always_inline void __SetPageLocked(struct page *page)
{__set_bit(PG_locked, &compound_head(page)->flags);
}static __always_inline void __ClearPageLocked(struct page *page)
{__clear_bit(PG_locked, &compound_head(page)->flags);
}static __always_inline int PageWaiters(struct page *page) { return test_bit(PG_waiters, &page->flags); }
static __always_inline void SetPageWaiters(struct page *page) { set_bit(PG_waiters, &page->flags); }
static __always_inline void ClearPageWaiters(struct page *page) { clear_bit(PG_waiters, &page->flags); }
static __always_inline void __ClearPageWaiters(struct page *page) { __clear_bit(PG_waiters, &page->flags); }static __always_inline int PageError(struct page *page) { return test_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline void SetPageError(struct page *page) { set_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline void ClearPageError(struct page *page) { clear_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline int TestClearPageError(struct page *page) { return test_and_clear_bit(PG_error, &compound_head(page)->flags); }static __always_inline int PageReferenced(struct page *page) { return test_bit(PG_referenced, &compound_head(page)->flags); } 
static __always_inline void SetPageReferenced(struct page *page) { set_bit(PG_referenced, &compound_head(page)->flags); } 
static __always_inline void ClearPageReferenced(struct page *page) { clear_bit(PG_referenced, &compound_head(page)->flags); }static __always_inline int TestClearPageReferenced(struct page *page)
{return test_and_clear_bit(PG_referenced, &compound_head(page)->flags);
}static __always_inline void __SetPageReferenced(struct page *page) { __set_bit(PG_referenced, &compound_head(page)->flags); }static __always_inline int PageDirty(struct page *page) { return test_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline void SetPageDirty(struct page *page) { set_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline void ClearPageDirty(struct page *page) { clear_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int TestSetPageDirty(struct page *page) { return test_and_set_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int TestClearPageDirty(struct page *page) { return test_and_clear_bit(PG_dirty, &compound_head(page)->flags); }static __always_inline void __ClearPageDirty(struct page *page) { __clear_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int PageLRU(struct page *page) { return test_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void SetPageLRU(struct page *page) { set_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void ClearPageLRU(struct page *page) { clear_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void __ClearPageLRU(struct page *page) { __clear_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline int PageActive(struct page *page) { return test_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void SetPageActive(struct page *page) { set_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void ClearPageActive(struct page *page) { clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void __ClearPageActive(struct page *page) { __clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline int TestClearPageActive(struct page *page) { return test_and_clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline int PageWorkingset(struct page *page) { return test_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline void SetPageWorkingset(struct page *page) { set_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline void ClearPageWorkingset(struct page *page) { clear_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline int TestClearPageWorkingset(struct page *page) { return test_and_clear_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline int PageSlab(struct page *page) { return test_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline void __SetPageSlab(struct page *page) { __set_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline void __ClearPageSlab(struct page *page) { __clear_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline int PageSlobFree(struct page *page) { return test_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline void __SetPageSlobFree(struct page *page) { __set_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline void __ClearPageSlobFree(struct page *page) { __clear_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline int PageChecked(struct page *page) { return test_bit(PG_checked, &page->flags); }
static __always_inline void SetPageChecked(struct page *page) { set_bit(PG_checked, &page->flags); }
static __always_inline void ClearPageChecked(struct page *page) { clear_bit(PG_checked, &page->flags); }static __always_inline int PagePinned(struct page *page) { return test_bit(PG_pinned, &page->flags); }
static __always_inline void SetPagePinned(struct page *page) { set_bit(PG_pinned, &page->flags); }
static __always_inline void ClearPagePinned(struct page *page) { clear_bit(PG_pinned, &page->flags); }
static __always_inline int TestSetPagePinned(struct page *page) { return test_and_set_bit(PG_pinned, &page->flags); }
static __always_inline int TestClearPagePinned(struct page *page) { return test_and_clear_bit(PG_pinned, &page->flags); }
static __always_inline int PageSavePinned(struct page *page) { return test_bit(PG_savepinned, &page->flags); }
static __always_inline void SetPageSavePinned(struct page *page) { set_bit(PG_savepinned, &page->flags); }
static __always_inline void ClearPageSavePinned(struct page *page) { clear_bit(PG_savepinned, &page->flags); };
static __always_inline int PageForeign(struct page *page) { return test_bit(PG_foreign, &page->flags); }
static __always_inline void SetPageForeign(struct page *page) { set_bit(PG_foreign, &page->flags); }
static __always_inline void ClearPageForeign(struct page *page) { clear_bit(PG_foreign, &page->flags); };
static __always_inline int PageXenRemapped(struct page *page) { return test_bit(PG_xen_remapped, &page->flags); }
static __always_inline void SetPageXenRemapped(struct page *page) { set_bit(PG_xen_remapped, &page->flags); }
static __always_inline void ClearPageXenRemapped(struct page *page) { clear_bit(PG_xen_remapped, &page->flags); }
static __always_inline int TestClearPageXenRemapped(struct page *page) { return test_and_clear_bit(PG_xen_remapped, &page->flags); }static __always_inline int PageReserved(struct page *page) { return test_bit(PG_reserved, &page->flags); }
static __always_inline void SetPageReserved(struct page *page) { set_bit(PG_reserved, &page->flags); }
static __always_inline void ClearPageReserved(struct page *page) { clear_bit(PG_reserved, &page->flags); }
static __always_inline void __ClearPageReserved(struct page *page) { __clear_bit(PG_reserved, &page->flags); }
static __always_inline void __SetPageReserved(struct page *page) { __set_bit(PG_reserved, &page->flags); }
static __always_inline int PageSwapBacked(struct page *page) { return test_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void SetPageSwapBacked(struct page *page) { set_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void ClearPageSwapBacked(struct page *page) { clear_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void __ClearPageSwapBacked(struct page *page) { __clear_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void __SetPageSwapBacked(struct page *page) { __set_bit(PG_swapbacked, &compound_head(page)->flags); }static __always_inline int PagePrivate(struct page *page) { return test_bit(PG_private, &page->flags); }
static __always_inline void SetPagePrivate(struct page *page) { set_bit(PG_private, &page->flags); }
static __always_inline void ClearPagePrivate(struct page *page) { clear_bit(PG_private, &page->flags); }
static __always_inline void __SetPagePrivate(struct page *page) { __set_bit(PG_private, &page->flags); }
static __always_inline void __ClearPagePrivate(struct page *page) { __clear_bit(PG_private, &page->flags); }
static __always_inline int PagePrivate2(struct page *page) { return test_bit(PG_private_2, &page->flags); }
static __always_inline void SetPagePrivate2(struct page *page) { set_bit(PG_private_2, &page->flags); }
static __always_inline void ClearPagePrivate2(struct page *page) { clear_bit(PG_private_2, &page->flags); }
static __always_inline int TestSetPagePrivate2(struct page *page) { return test_and_set_bit(PG_private_2, &page->flags); }
static __always_inline int TestClearPagePrivate2(struct page *page) { return test_and_clear_bit(PG_private_2, &page->flags); }
static __always_inline int PageOwnerPriv1(struct page *page) { return test_bit(PG_owner_priv_1, &page->flags); }
static __always_inline void SetPageOwnerPriv1(struct page *page) { set_bit(PG_owner_priv_1, &page->flags); }
static __always_inline void ClearPageOwnerPriv1(struct page *page) { clear_bit(PG_owner_priv_1, &page->flags); }
static __always_inline int TestClearPageOwnerPriv1(struct page *page) { return test_and_clear_bit(PG_owner_priv_1, &page->flags); }static __always_inline int PageWriteback(struct page *page) { return test_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int TestSetPageWriteback(struct page *page) { return test_and_set_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int TestClearPageWriteback(struct page *page) { return test_and_clear_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int PageMappedToDisk(struct page *page) { return test_bit(PG_mappedtodisk, &compound_head(page)->flags); }
static __always_inline void SetPageMappedToDisk(struct page *page) { set_bit(PG_mappedtodisk, &compound_head(page)->flags); }
static __always_inline void ClearPageMappedToDisk(struct page *page) { clear_bit(PG_mappedtodisk, &compound_head(page)->flags); }static __always_inline int PageReclaim(struct page *page) { return test_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline void SetPageReclaim(struct page *page) { set_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline void ClearPageReclaim(struct page *page) { clear_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline int TestClearPageReclaim(struct page *page) { return test_and_clear_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline int PageReadahead(struct page *page) { return test_bit(PG_reclaim, &page->flags); }
static __always_inline void SetPageReadahead(struct page *page) { set_bit(PG_reclaim, &page->flags); }
static __always_inline void ClearPageReadahead(struct page *page) { clear_bit(PG_reclaim, &page->flags); }
static __always_inline int TestClearPageReadahead(struct page *page) { return test_and_clear_bit(PG_reclaim, &page->flags); }static inline int PageHighMem(const struct page *page) { return 0; }
static inline void SetPageHighMem(struct page *page) { }
static inline void ClearPageHighMem(struct page *page) { }static __always_inline int PageSwapCache(struct page *page)
{return PageSwapBacked(page) && test_bit(PG_swapcache, &page->flags);
}
static __always_inline void SetPageSwapCache(struct page *page) { set_bit(PG_swapcache, &compound_head(page)->flags); }
static __always_inline void ClearPageSwapCache(struct page *page) { clear_bit(PG_swapcache, &compound_head(page)->flags); }static __always_inline int PageUnevictable(struct page *page) { return test_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void SetPageUnevictable(struct page *page) { set_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void ClearPageUnevictable(struct page *page) { clear_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void __ClearPageUnevictable(struct page *page) { __clear_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline int TestClearPageUnevictable(struct page *page) { return test_and_clear_bit(PG_unevictable, &compound_head(page)->flags); }static __always_inline int PageMlocked(struct page *page) { return test_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline void SetPageMlocked(struct page *page) { set_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline void ClearPageMlocked(struct page *page) { clear_bit(PG_mlocked, &compound_head(page)->flags); }static __always_inline void __ClearPageMlocked(struct page *page) { __clear_bit(PG_mlocked, &compound_head(page)->flags); }static __always_inline int TestSetPageMlocked(struct page *page) { return test_and_set_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline int TestClearPageMlocked(struct page *page) { return test_and_clear_bit(PG_mlocked, &compound_head(page)->flags); }static inline int PageUncached(const struct page *page) { return 0; }
static inline void SetPageUncached(struct page *page) { }
static inline void ClearPageUncached(struct page *page) { }static inline int PageHWPoison(const struct page *page) { return 0; }
static inline void SetPageHWPoison(struct page *page) { }
static inline void ClearPageHWPoison(struct page *page) { }
static inline bool set_hwpoison_free_buddy_page(struct page *page)
{return 0;
}static __always_inline int PageMappingFlags(struct page *page)
{return ((unsigned long)page->mapping & (0x1 | 0x2)) != 0;
}static __always_inline int PageAnon(struct page *page)
{page = compound_head(page);return ((unsigned long)page->mapping & 0x1) != 0;
}static __always_inline int __PageMovable(struct page *page)
{return ((unsigned long)page->mapping & (0x1 | 0x2)) == 0x2;
}static inline int PageKsm(const struct page *page) { return 0; }u64 stable_page_flags(struct page *page);static inline int PageUptodate(struct page *page)
{int ret;page = compound_head(page);ret = test_bit(PG_uptodate, &(page)->flags);if (ret)smp_rmb();return ret;
}static __always_inline void __SetPageUptodate(struct page *page)
{VM_BUG_ON_PAGE(PageTail(page), page);smp_wmb();__set_bit(PG_uptodate, &page->flags);
}static __always_inline void SetPageUptodate(struct page *page)
{VM_BUG_ON_PAGE(PageTail(page), page);smp_wmb();set_bit(PG_uptodate, &page->flags);
}static __always_inline void ClearPageUptodate(struct page *page) { clear_bit(PG_uptodate, &compound_head(page)->flags); }int test_clear_page_writeback(struct page *page);
int __test_set_page_writeback(struct page *page, bool keep_write);static inline void set_page_writeback(struct page *page)
{__test_set_page_writeback(page, false);
}static inline void set_page_writeback_keepwrite(struct page *page)
{__test_set_page_writeback(page, true);
}static __always_inline int PageHead(struct page *page) { return test_bit(PG_head, &page->flags); }
static __always_inline void __SetPageHead(struct page *page) { __set_bit(PG_head, &page->flags); }
static __always_inline void __ClearPageHead(struct page *page) { __clear_bit(PG_head, &page->flags); }
static __always_inline void ClearPageHead(struct page *page) { clear_bit(PG_head, &page->flags); }static __always_inline void set_compound_head(struct page *page, struct page *head)
{WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
}static __always_inline void clear_compound_head(struct page *page)
{WRITE_ONCE(page->compound_head, 0);
}static inline int PageHuge(const struct page *page) { return 0; }
static inline int PageHeadHuge(const struct page *page) { return 0; }static inline bool page_huge_active(struct page *page)
{return 0;
}static inline int PageTransHuge(const struct page *page) { return 0; }
static inline int PageTransCompound(const struct page *page) { return 0; }
static inline int PageTransCompoundMap(const struct page *page) { return 0; }
static inline int PageTransTail(const struct page *page) { return 0; }
static inline int PageDoubleMap(const struct page *page) { return 0; }
static inline void SetPageDoubleMap(struct page *page) { }
static inline void ClearPageDoubleMap(struct page *page) { }
static inline int TestSetPageDoubleMap(struct page *page) { return 0; }
static inline int TestClearPageDoubleMap(struct page *page) { return 0; }#define PAGE_TYPE_BASE    0xf0000000
/* Reserve        0x0000007f to catch underflows of page_mapcount */
#define PAGE_MAPCOUNT_RESERVE    -128
#define PG_buddy    0x00000080
#define PG_offline    0x00000100
#define PG_kmemcg    0x00000200
#define PG_table    0x00000400
#define PG_guard    0x00000800static inline int page_has_type(struct page *page)
{return (int)page->page_type < PAGE_MAPCOUNT_RESERVE;
}/* 由 PAGE_TYPE_OPS 宏展开 */
static __always_inline int PageBuddy(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_buddy)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageBuddy(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_buddy; }
static __always_inline void __ClearPageBuddy(struct page *page) { VM_BUG_ON_PAGE(!PageBuddy(page), page); page->page_type |= PG_buddy; }static __always_inline int PageOffline(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_offline)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageOffline(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_offline; }
static __always_inline void __ClearPageOffline(struct page *page) { VM_BUG_ON_PAGE(!PageOffline(page), page); page->page_type |= PG_offline; }static __always_inline int PageKmemcg(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_kmemcg)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageKmemcg(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_kmemcg; }
static __always_inline void __ClearPageKmemcg(struct page *page) { VM_BUG_ON_PAGE(!PageKmemcg(page), page); page->page_type |= PG_kmemcg; }static __always_inline int PageTable(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_table)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageTable(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_table; }
static __always_inline void __ClearPageTable(struct page *page) { VM_BUG_ON_PAGE(!PageTable(page), page); page->page_type |= PG_table; }static __always_inline int PageGuard(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_guard)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageGuard(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_guard; }
static __always_inline void __ClearPageGuard(struct page *page) { VM_BUG_ON_PAGE(!PageGuard(page), page); page->page_type |= PG_guard; }extern bool is_free_buddy_page(struct page *page);static __always_inline int PageIsolated(struct page *page) { return test_bit(PG_isolated, &page->flags); }
static __always_inline void __SetPageIsolated(struct page *page) { __set_bit(PG_isolated, &page->flags); }
static __always_inline void __ClearPageIsolated(struct page *page) { __clear_bit(PG_isolated, &page->flags); };static inline int PageSlabPfmemalloc(struct page *page)
{VM_BUG_ON_PAGE(!PageSlab(page), page);return PageActive(page);
}static inline void SetPageSlabPfmemalloc(struct page *page)
{VM_BUG_ON_PAGE(!PageSlab(page), page);SetPageActive(page);
}static inline void __ClearPageSlabPfmemalloc(struct page *page)
{VM_BUG_ON_PAGE(!PageSlab(page), page);__ClearPageActive(page);
}static inline void ClearPageSlabPfmemalloc(struct page *page)
{VM_BUG_ON_PAGE(!PageSlab(page), page);ClearPageActive(page);
}#define PAGE_FLAGS_PRIVATE                \(1UL << PG_private | 1UL << PG_private_2)static inline int page_has_private(struct page *page)
{return !!(page->flags & PAGE_FLAGS_PRIVATE);
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/957166.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

25.11.05

25.11.05

AGC004E 运动是相对的，显然考虑挪动出口。 假设我们向四个方向最远移动分别是 \(u,d,l,r\)，那么大矩形会从外往内删掉 \(d,u,r,l\)。 而注意到我们这个 \(u,d,l,r\) 框出的范围实质是个矩形，在这个矩形内造成的删除…
阅读更多...
在React中实现路由跳转

在React中实现路由跳转

在 React 中实现路由跳转可以使用多种方法，主要依赖于 react-router-dom 库。 常见的路由跳转方法 使用 useNavigate 钩子（适用于 react-router-dom v6）: 1. useNavigate 是一个钩子，允许在函数组件中进行编程式导…
阅读更多...
2025 11 4+11 5

2025 11 4+11 5

11.4号这个只有一个上午的时间来着，晚上和中午我被弄去搞WHK了/jk vp 第十七场 T1 评分：绿直接秒了，倒着弄+并查集即可(用时20min)T2 评分：蓝这个我经过了一系列的思考才得出解法来着 首先我先观察到了 \(k_i \cdo…
阅读更多...
022304105叶骋恺数据采集第二次作业

022304105叶骋恺数据采集第二次作业

作业1 代码与运行结果 class WeatherForecast:def __init__(self):self.headers = {"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 6.0 x64; en-US; rv:1.9pre) Gecko/2008072421 Minefield/3.0…
阅读更多...
2025.11.5模拟赛

2025.11.5模拟赛

赛时T1，T2看完都有锅，然后节奏有点乱了，改完题面后，写了T1，但是没太细想，所以出了很多问题，幸好写了一个拍，然后一边拍一边改错2h30min就过去了 调整了一下状态，T2看了一会，切了，但是考虑到一个细节，忘写了…
阅读更多...
ai编程第一次实战

ai编程第一次实战

ai编程第一次实战安装uniapp的ide hbuilder, 配置nodejs环境, 安装trae ide hbuilder先创建新项目, 选择空白模板 ,项目文件名叫test trae打开这个项目test文件夹, 然后输入提示词. 用uniapp框架写一个留言板功能(不要…
阅读更多...
WordPress Social Feed Gallery插件未授权信息泄露漏洞分析

WordPress Social Feed Gallery插件未授权信息泄露漏洞分析

本文详细分析了CVE-2025-10637漏洞，该漏洞影响WordPress Social Feed Gallery插件4.9.2及以下版本，由于缺少授权验证导致未认证攻击者能够窃取Instagram个人资料和媒体数据。概述 CVE-2025-10637是一个影响WordPress…
阅读更多...
[题解]P14094 [ICPC 2023 Seoul R] Special Numbers

[题解]P14094 [ICPC 2023 Seoul R] Special Numbers

P14094 [ICPC 2023 Seoul R] Special Numbers 数位 DP。 考虑使用 \(f[pos][g]\) 记忆化，其中：\(pos\) 表示当前填到第几位。 \(g\) 表示填过位置的乘积与 \(k\) 的 \(\gcd\)。根据这个表格我们知道，\(10^{17}\) 内…
阅读更多...
ASP.NET Core Blazor 核心功能三：Blazor与JavaScript互操作——让Web开发更灵活

ASP.NET Core Blazor 核心功能三：Blazor与JavaScript互操作——让Web开发更灵活

嗨，大家好！我是码农刚子。今天我们来聊聊Blazor中C#与JavaScript互操作。我知道很多同学在听到"Blazor"和"JavaScript"要一起工作时会有点懵，但别担心，我会用最简单的方式带你掌握这个技能！ …
阅读更多...
测试思维的培养

测试思维的培养

一、作为一个测试人员养成一个测试思维: 当被测物体给到你，你就会从哪些角度去考虑 （1）需求测试:（全称：软件需求规格说明书，文档） 测试需求错别字、合理、冗余、规范、唯一性、 （2）界面测试：（也叫ui测试） …
阅读更多...
NOIP2025模拟2 改题记录

NOIP2025模拟2 改题记录

HZOJ 写在前面 CSP后第一场。回归CSP前的手感，就是啥也不会。今年第一场4.5h的模拟赛，确实没有4h时间紧张了，还有大把时间犯困，可能是CSP破防了摆烂了吧。今天提前出成绩了，大概就是挂如分了，估计得卡着七钩线。…
阅读更多...
10-16

10-16

（1）今天预习了动态规划 （2）今天学习了web （2）明天继续深造
阅读更多...
ASP.NET Core Blazor 核心功能二：Blazor与JavaScript互操作——让Web开发更灵活

ASP.NET Core Blazor 核心功能二：Blazor与JavaScript互操作——让Web开发更灵活

嗨，大家好！我是码农刚子。今天我们来聊聊Blazor中C#与JavaScript互操作。我知道很多同学在听到"Blazor"和"JavaScript"要一起工作时会有点懵，但别担心，我会用最简单的方式带你掌握这个技能！ …
阅读更多...
10-15

10-15

（1）今天预习了java的课程 （2）明天继续深造
阅读更多...
10-14

10-14

（1）今天预习了java的课程 （2）明天继续深造
阅读更多...
模拟赛 32

模拟赛 32

没打。USS Enrerprise(CVN-80) 什么时候服役我什么时候补。
阅读更多...
top 命令的load average和vmstat 的r列和b列的关系是什么？区别又是什么？

top 命令的load average和vmstat 的r列和b列的关系是什么？区别又是什么？

最近在复习linux系统负载问题排查，主要涉及到cpu,内存,io，网络等指标的一些习惯的linux命令，发现top命令的load average指标和vmstat指标的r列以及b列似乎有些联系，但是又搞不懂具体是什么关系，又有什么区别，于是…
阅读更多...
2025-11-1

2025-11-1

C
阅读更多...
高级程序语言设计第4次作业

高级程序语言设计第4次作业

这个作业属于：https://edu.cnblogs.com/campus/fzu/gjyycx 这个作业的要求：https://edu.cnblogs.com/campus/fzu/gjyycx/homework/14577 学号：102500416 姓名：王浩宇 第一项 运行以下代码12第二项老师布置的题目1d…
阅读更多...
2025-11-5

2025-11-5

C++
阅读更多...
最新文章

Copyright @ 2022~2023