tensorflow:: מָנָה:: BasicManager

זהו שיעור מופשט.

#include <basic_manager.h>

עוזר לנהל את מחזור החיים של חומרי הגשה כולל טעינה, הגשה ופריקה שלהם.

סיכום

המנהל מקבל קבצים להגשה בצורה של Loaders.

אנו מתחילים לנהל קובץ הגשה באמצעות אחת משיטות ManageServable*. אתה יכול להמשיך לטעון את servable אחרי זה באמצעות הטלפון LoadServable () . הטעינה גם תהפוך את הניתן להגשה זמין להגשה. ברגע שאתה מחליט לפרוק אותה, אתה יכול להתקשר UnloadServable () על זה, אשר יהפוך אותן לבלתי לשרת, אז לפרוק את servable.

Servables נשמרת עד StopManagingServable () נקראת. זה מאפשר למנהל ברמה גבוהה יותר עם מידע רב יותר להחליט מתי בטוח לשכוח קובץ שניתן להגשה.

BasicManager עוקב משאבים (RAM למשל) המשמשים servables טעון, ורק מאפשר טעינת servables החדש שמתאים בתוך בריכה המשאבים הכוללת.

BasicManager יכול להיות מוגדר לשימוש א-מאגר חוט כדי לעשות עומס של אותו ופורק. זה הופך את LoadServable () ו UnloadServable () שיטות לתזמן את העומס / מסיר ולא להוציא אותם להורג באופן סינכרוני. אם יש יותר טעינה/פריקה בהמתנה מאשר שרשורים במאגר השרשורים, הם מעובדים בסדר FIFO.

בנוכחות מעמיסים שמעריכים יתר על המידה את צורכי המשאבים הניתנים לשרת שלהם ו/או רק קושרים את משאבי השרתים שלהם למופעי מכשירים, ניתן להפחית את במקביליות הטעינה/פריקה מתחת לגודל מאגר השרשורים. הסיבה לכך היא שאולי נצטרך להמתין לסיום הטעינה/פריקה של רכיב שרת אחד כדי לקבוע את זמינות המשאב לטעינת רכיב שרת אחר.

דורש:

  1. סדר הקריאות שיטת - ManageServable () (וגירסאות) -> LoadServable () -> UnloadServable () -> StopManagingServable () .
  2. אין לתזמן טעינה ופריקות בו-זמנית של אותו חומר הגשה.
  3. אל תתקשר לטעון או לפרוק מספר פעמים על אותו קובץ הגשה.

מחלקה זו בטוחה לשרשור.

שימוש לדוגמה: 

const ServableId id = {kServableName, 0};
std::unique_ptr<Loader> loader = ...;
...
BasicManager manager;
TF_CHECK_OK(manager.ManageServable(
  CreateServableData(id, std::move(loader))));
TF_CHECK_OK(manager.LoadServable(id));

...
TF_CHECK_OK(manager.GetServableHandle(
    ServableRequest::Latest(kServableName), &handle));
...

TF_CHECK_OK(manager.UnloadServable(id));
TF_CHECK_OK(manager.StopManagingServable(id));

יְרוּשָׁה

יורש מ: tensorflow :: המשרת :: מנהל

בנאים והורסים

~BasicManager ()
אם מוגדר להשתמש במאגר של טעינה/פריקה, ממתין עד לסיום כל הטעינות והפריקות המתוזמנות ולאחר מכן הורס את ערכת השרשורים.

טיפוסים ציבוריים

DoneCallback באמצעות
std::function< void(const Status &status)>
התקשרות חוזרת נקראת בסוף {Load,Unload}Servable().
PreLoadHook באמצעות
std::function< void(const ServableId &)>

חוגי חברים

test_util::BasicManagerTestAccess
friend class

פונקציות סטטיות ציבוריות

Create ( Options options, std::unique_ptr< BasicManager > *manager)
Status

תפקידים ציבוריים

CancelLoadServableRetry (const ServableId & id)
void
בטל שתנסה שוב את עומס servable במהלך LoadServable () .
GetAdditionalServableState (const ServableId & id)
T *
GetAvailableUntypedServableHandles () const override
virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > >
GetManagedServableNames () const
std::vector< string >
GetManagedServableStateSnapshot (const ServableId & id)
optional< ServableStateSnapshot< T > >
GetManagedServableStateSnapshots (const string & servable_name) const
std::vector< ServableStateSnapshot< T > >
GetUntypedServableHandle (const ServableRequest & request, std::unique_ptr< UntypedServableHandle > *untyped_handle) override
virtual Status
ListAvailableServableIds () const override
virtual std::vector< ServableId >
מקבל רשימה של כל המזהים הזמינים להגשה, כלומר
LoadServable (const ServableId & id, DoneCallback done_callback)
void
טוען את קובץ ההגשה עם המזהה הזה, ומעדכן גם את מפת ההגשה.
ManageServable (ServableData< std::unique_ptr< Loader >> servable)
Status
מתחיל לנהל את הניתן להגשה.
ManageServableWithAdditionalState (ServableData< std::unique_ptr< Loader >> servable, std::unique_ptr< T > additional_state)
Status
בדומה לשיטה שלעיל, אבל מתקשרים, בדרך כלל מנהלים אחרים שנבנו על השיטה הזו, יכולים לשייך מצב נוסף לשרת.
StopManagingServable (const ServableId & id)
Status
אומר למנהל להפסיק לנהל את קובץ ההגשה הזה.
UnloadServable (const ServableId & id, DoneCallback done_callback)
void
פורק את הניתן להגשה עם המזהה הזה, ומעדכן גם את מפת ההגשה.

מבנים

tensorflow :: המשרתים :: BasicManager :: אפשרויות

אפשרויות Config וחפצים לחיבור אשר ישמשו ידי BasicManager .

טיפוסים ציבוריים

הסתיימה התקשרות חזרה

std::function< void(const Status &status)> DoneCallback

התקשרות חוזרת נקראת בסוף {Load,Unload}Servable().

אנו מעבירים בסטטוס המבצע להתקשרות חוזרת.

PreLoadHook

std::function< void(const ServableId &)> PreLoadHook

חוגי חברים

test_util::BasicManagerTestAccess

friend class test_util::BasicManagerTestAccess

פונקציות סטטיות ציבוריות

לִיצוֹר

Status Create(
  Options options,
  std::unique_ptr< BasicManager > *manager
)

תפקידים ציבוריים

CancelLoadServableRetry

void CancelLoadServableRetry(
  const ServableId & id
)

בטל שתנסה שוב את עומס servable במהלך LoadServable () .

לא עושה כלום אם ההגשה לא מנוהל.

אם הניסיונות החוזרים מבוטלים, השרת נכנס למצב התלוי ב-Load() האחרון שנקרא עליו. אם ה-Load() האחרון הצליח, הוא יהיה במצב kReady, אחרת ב-kError.

GetAdditionalServableState

T * GetAdditionalServableState(
  const ServableId & id
)

דורש: המנהל הזה היה צריך לנהל את השרת הזה כבר, אחרת אנחנו מחזירים nullptr.

פרטים
החזרות
המצב הנוסף עבור הניתן להגשה. מחזירה nullptr אם אין הגדרת מצב נוספת או אם יש חוסר התאמה בין מה שהוגדר למה שמתבקש.

GetAvailableUntypedServableHandles

virtual std::map< ServableId, std::unique_ptr< UntypedServableHandle > > GetAvailableUntypedServableHandles() const override

GetManagedServableNames

std::vector< string > GetManagedServableNames() const

פרטים
החזרות
השמות של כל המנות המנוהלות על ידי מנהל זה. השמות יהיו ללא כפילויות ולא בסדר מסוים.

GetManagedServableStateSnapshot

optional< ServableStateSnapshot< T > > GetManagedServableStateSnapshot(
  const ServableId & id
)

דרישות: המנהל הזה היה צריך לנהל כבר את השרת הזה, אחרת אנחנו מחזירים nullopt.

פרטים
החזרות
תמונת המצב של מזהה שניתן להגשה מסוים המנוהל על ידי מנהל זה, אם זמין.

GetManagedServableStateSnapshots

std::vector< ServableStateSnapshot< T > > GetManagedServableStateSnapshots(
  const string & servable_name
) const

T הוא סוג המצב הנוסף, אם קיים.

פרטים
החזרות
את תמונת המצב של כל השרתים של זרם מסוים, המנוהלים על ידי מנהל זה.

GetUntypedServableHandle

virtual Status GetUntypedServableHandle(
  const ServableRequest & request,
  std::unique_ptr< UntypedServableHandle > *untyped_handle
) override

ListAvailableServableIds

virtual std::vector< ServableId > ListAvailableServableIds() const override

מקבל רשימה של כל המזהים הזמינים להגשה, כלומר

ניתן לאחזר כל אחד מאלה באמצעות GetServableHandle.

LoadServable

void LoadServable(
  const ServableId & id,
  DoneCallback done_callback
)

טוען את קובץ ההגשה עם המזהה הזה, ומעדכן גם את מפת ההגשה.

שיחות done_callback עם אישור IFF servable נטענה בהצלחה, חוזר אחר בעל מעמד שגיאה.

אם משתמשים ב-Thread-pool, שיטה זו מעבירה את הרתמה הניתנת להגשה למצב kLoading, מתזמנת את העומס וחוזרת, אחרת היא משלימה את הטעינה לפני החזרה.

דורש: מנהל זה היה צריך לנהל servable זה כבר, על מנת שניתן יהיה טעון, אחר שאנו מכנים done_callback עם מצב שגיאה. אל תקרא לזה מספר פעמים על אותו קובץ הגשה. רק אחד מהם יצליח והשאר ייכשלו עם סטטוס שגיאה.

ManageServable

Status ManageServable(
  ServableData< std::unique_ptr< Loader >> servable
)

מתחיל לנהל את הניתן להגשה.

מחזיר שגיאה אם ​​ניתן להגשה שכבר מנוהל.

אם servable הוא במצב שגיאה, שיטה זו אינה מחזירה שגיאה. במקום זאת, המנהל מקבל את קובץ ההגשה, מעביר אותו למצב kError (עם הודעה שנשלחה לאוטובוס האירוע), ואז מיד מפסיק לנהל אותו. התנהגות זו מאפשרת טיפול אחיד בשגיאות המתרחשות במקורות (למשל נתיב קובץ לא חוקי לנתונים הניתנים להצגה) וכאלה המתרחשות במנהל (למשל, אין מספיק משאבים לטעינת קבצים שניתן להגיש).

ManageServableWithAdditionalState

Status ManageServableWithAdditionalState(
  ServableData< std::unique_ptr< Loader >> servable,
  std::unique_ptr< T > additional_state
)

בדומה לשיטה שלעיל, אבל מתקשרים, בדרך כלל מנהלים אחרים שנבנו על השיטה הזו, יכולים לשייך מצב נוסף לשרת.

מצב נוסף עשוי להיות ACL או מטא נתונים לכל החיים עבור אותו ניתן להגשה. הבעלות על המדינה מועברת למעמד זה.

StopManagingServable

Status StopManagingServable(
  const ServableId & id
)

אומר למנהל להפסיק לנהל את קובץ ההגשה הזה.

מחייב שהקובץ המשרת מנוהל כעת ושהמצב שלו הוא אחד של {kNew, kError, kDisabled}.

UnloadServable

void UnloadServable(
  const ServableId & id,
  DoneCallback done_callback
)

פורק את הניתן להגשה עם המזהה הזה, ומעדכן גם את מפת ההגשה.

שיחות done_callback עם אישור IFF servable נפרק בהצלחה, חוזר אחר בעל מעמד שגיאה.

אם משתמשים ב-thread-pool, שיטה זו מעבירה את הרתמה הניתנת להגשה למצב kQuiescing, מתזמנת את הפריקה וחוזרת, אחרת היא משלימה את הפריקה לפני החזרה.

דורש: מנהל זה צריך טעון ועשה זאת servable זמין, על מנת שניתן יהיה פרקו, שיחות אחרות done_callback עם מצב שגיאה. אל תקרא לזה מספר פעמים על אותו קובץ הגשה. רק אחד מהם יצליח והשאר ייכשלו עם סטטוס שגיאה.

~מנג'ר בסיסי

 ~BasicManager() override

אם מוגדר להשתמש במאגר של טעינה/פריקה, ממתין עד לסיום כל הטעינות והפריקות המתוזמנות ולאחר מכן הורס את ערכת השרשורים.