The Geometric Satake Correspondence for Ramified Groups
Summary (6 min read)
1. Introduction
- A distributed computing system consists of heterogeneous computing devices, communication networks, operating system services, and applications.
- The authors approach to distributed applications management requires instrumentation; that is, code inserted into the application at strategic locations so a managed process can maintain management information, respond to management requests and generate event reports.
- This research work is supported by the IBM Centre for Advanced Studies and the Natural Sciences and Engineering Research Council of Canada.
- By developing an instrumentation architecture, the authors can make e orts toward automating some parts of the process, and provide guidance to facilitate the development of custom instrumentation in a controlled and structured manner.
- Section 2 outlines some of the major objectives guiding the current work.
2. Objectives
- A number of general objectives were established to guide their study of instrumentation and to in¯uence the development and re®nement of their instrumentation architecture and prototype.
- For e ective management, the authors must be able to acquire information on the processes being managed.
- Similarly, the architecture should accommodate a wide range of management functions including performance, accounting, fault tolerance, and security.
- The instrumentation architecture should support the automation of the instrumentation process, so it can be done with little developer e ort.
- In addition to reducing developer e ort, the notion of run-time transparency must be observed; users of managed applications should not be aware of substantial performance overhead caused by management.
3. Management environment
- The authors de®ne the general framework of their distributed applications management system.
- An agent receives management requests from managers and carries out the operations on the appropriate managed objects.
- Fig. 2 illustrates the basic components of an agent architecture and how they interact with managed processes.
- The managed object interface is used to coordinate requests on managed objects and to handle emitted noti®cations.
- Process managed object classes are specialized through inheritance to re¯ect their unique characteristics including communication environment (sockets, DCE Remote Procedure Calls (RPCs), etc.), process role (client, server, or peer), and application type (database, etc.).
4. Instrumentation architecture
- Having identi®ed the key objectives of instrumentation for managing distributed applications, the authors re®ne the management architecture developed in their previous work (Hong et al., 1995b, c; Katchabaw et al., 1996a) to re¯ect their current focus on instrumentation.
- In Section 4, the authors describe the key components of the architecture and the interactions that occur between these components.
4.1. Instrumentation component overview
- In Fig. 3, Instrumented Process 1 has been expanded to reveal a set of instrumentation components.
- The coordinator is also responsible for creating and destroying sensors and actuators, as well as performing management initialization and termination activities within the managed process.
- One can think of a sensor as a reusable software component that can be plugged into an application process via one or more probes for the purpose of capturing management data.
- For other application-speci®c information, custom sensors can be built or derived from standard sensors.
- As for sensors, it is anticipated that application developers will view actuators as reusable parts which can be plugged into an application process via one or more probes to provide speci®c control functions.
4.2. Service interfaces
- The service interfaces represent points of interactions between the managed process (through the management coordinator) and the agent.
- The authors will ®rst present the interface of the agent that is used by the managed process.
- The authors will then present the interface of the managed process used by the agent.
4.2.1. Managed process to agent
- Acquiring management information is critical to the management of distributed applications.
- The authors must be able to support two types of ¯ow of information: (i) the periodic sending of management information to the agent, and (ii) the ability to send information when a signi®cant event occurs.
- Id represent the process name and identi®er.
- Noti®es the agent of the termination of the process in the context of the normal operation of the application, also known as Process_notifyTermination.
- ServerType speci®es the type of server process that failed.
4.2.2. Agent to managed process
- This service is used by the management agent to request information from managed processes in the system.
- By specifying the set of attributes to retrieve, the appropriate information is returned to the agent.
- This service instructs the process to terminate as quickly as possible.
- Operations include the following: Process_controlManageProcess: Activates management in a process, informing the process which agent will be managing it.
- For periodic reports, this operation can change the interval between reports.
4.3. Interactions
- The interactions between the management system and managed processes include requests from the management system to the processes and reports ¯owing in the other direction.
- Requests can be made to retrieve management information, exert control over a managed process, or to change the way in which a process is being managed.
- Reports are generated at process initialization, at periodic intervals, upon the detection of alarm conditions, and at process termination.
- The authors describe the roles of the instrumentation components presented in Fig. 3 as they relate to these interactions.
4.3.1. Management system to instrumentation interactions
- Requests from the management system to an instrumented process are received by its management coordinator which, in turn, routes them to the appropriate instrumentation components as follows: · A request for management information is sent as a read request to the sensor (or sensors) responsible for the infor- mation requested.
- The state for the sensors is updated by the sensors' probes, or through interactions with other sensors.
- The results are returned through the coordinator to the management system.
- · A request to execute a control operation is sent as an action request to the actuator (or actuators) responsible for that operation.
- If the request calls for the collection of additional management information, new sensors are created or existing ones are enabled.
4.3.2. Instrumentation to management system interactions
- Reports from process instrumentation to the management system go through the management coordinator.
- There are a variety of circumstances in which such reports are sent from the coordinator to the management system.
- This co- ordinator then creates and enables a default set of sensors and actuators.
- To register with the management system (notifying the system of the existence of the instrumented process and of an interface through which the process can be managed), the coordinator issues read requests to the appropriate sensors to gather the information.
- The sensors return this state information, which was originally collected by their probes.
5.1. Placing instrumentation
- For e ective management of a distributed application process, instrumentation probes must be inserted at strategic locations (probe points) in the process source code.
- Other instrumentation components (the management coordinator, sensors, and actuators) are located in the same address space as the process, but do not need to be placed within the original code of the process.
- Every process entry point must be instrumented with probes to allow instrumentation to initialize and to allow process registration to occur.
- At these points, performance metrics can be computed, faults can be detected, accounting can be performed, security policies can be validated, and application con®guration may be changed.
- The above list of probe points is not exhaustive, but gives a strong sense of the level of instrumentation required for manageability.
5.2. Performing instrumentation
- In the previous section, the authors described the process of instrumentation and identi®ed the strategic points in source code where probes should be placed.
- The authors examine several instrumentation techniques and the relative merits of each.
- Fig. 4 illustrates the alternative approaches the authors consider.
5.2.1. Hand-coded instrumentation
- Most application process instrumentation is carried out by hand during application development.
- In their work, the authors try to make use of standard components and apply them in a prescribed manner to achieve a degree of consistency across applications and minimize the risk of error.
- A substantial amount of time, e ort, and resources can be expended instrumenting an application in this way.
- Tools to automate the insertion of probes would greatly enhance this procedure.
5.2.2. Function or class wrapper instrumentation
- One possible method of automating the instrumentation process is to provide application developers with management ``wrappers'' for functions, data structures, or objects.
- A management wrapper mf around a function f might be implemented as p1 f p2, where p1 and p2 are standard probes.
- To make use of the function f, mf is called instead (although its name is probably still the same), with the same result produced.
- The same concept applies to wrapping data structures and objects.
- Wrappers can help automate basic instrumentation and reduce somewhat the e ort and risk of human error.
5.2.3. IDL instrumentation
- Many distributed application computing environments use a formal Interface De®nition Language (IDL) through which attributes and procedure or object method signatures are speci®ed.
- IDL compilers could be modi®ed to insert probes automatically when generating communications stub code.
- This approach would further reduce the e ort and risk of programmer error problems associated with probe insertion, but at a cost of some ¯exibility and customizability.
- Since stub code is normally produced in the source language of the application, the developer does have opportunity to access and modify generated stubs, buying back some of the lost ¯exibility.
- Editing stub code is usually considered a dangerous and messy practice.
5.2.4. System library or compiler instrumentation
- A fourth approach hides most of the instrumentation procedure from the application developer.
- By providing instrumented system libraries or a compiler that injects instrumentation at compile-time, most of the instrumentation task is handled automatically.
- This could not otherwise be done by the developer alone.
- Perhaps the best example of work on this type of internal instrumentation can be found in (OSF, 1993, 1995); however, this work is aimed mainly at performance measurement rather than general management.
- Clearly, there is a need for automation to reduce the e ort and inherent risk of instrumentation by hand.
6.1. Management environment
- The prototype builds upon University College London's OSI Management Information Service (Pavlou et al., 1993, 1991) which provides an object-oriented infrastructure for developing management applications and OSI agents.
- OSIMIS includes a compiler (Cowan, 1993) to parse managed object class de®nitions (speci®ed in the Guidelines for the De®nition of Managed Objects (GDMO) (ISO, 1991c)) and generate the agent code required to access those managed objects.
- Through extensions to OSIMIS, their management system is capable of managing DCE distributed applications for a variety of management tasks.
6.2. Instrumentation implementation
- Instrumentation is provided to application developers through a C++ class library.
- The library contains a variety of standard sensors, actuators, and management coordinators.
- The library can also be specialized to develop new classes of instrumentation components to meet the unique needs of speci®c applications.
- Figs. 5±7 show class hierarchies for management coordinators, sensors, and actuators, respectively, implemented to date.
6.2.1. Management coordinator
- Interactions between the management system and the managed processes can be carried out using di erent communication protocols that include standard DCE RPCs and sockets.
- Di erent management systems can be supported by replacing the management coordinator.
- If the management coordinator uses DCE for communication between the instrumented processes and management agents and then changes to sockets then the authors would only have to replace the management coordinator; the sensors and actuators do not change.
- Coordinator routines have also been developed to initialize the instrumentation, to route internal messages, and to manage sensors and actuators.
- A scheduler routine in the coordinator handles time-based events; this has been implemented as a separate execution thread.
6.2.2. Sensors and actuators
- In the current prototype, the instrumentation library includes the following categories of sensors and actuators.
- Registration sensors allow processes and applications to be registered with the management system so that the system is aware of their existence.
- These include remote procedure call timeouts, server congestion, middleware service failures, failed ®le or network operations, and other abnormal and undesirable conditions.
- Resource utilization sensors collect information that characterizes the impact a process is having on system hardware resources, including memory, CPU, disk, and network usage measures.
- Process control actuators control process termination, process suspension, process priority modi®cation and change the length of the interval between RPC statistics event reports.
6.2.3. Probes
- The following probes were inserted into the source code of distributed applications by hand.
- Since the authors are using DCE they retrieve the binding handle of the agent using the Cell Directory Service (CDS).
- A management thread is created that becomes the management coordinator and the sensors.
- This probe noti®es an agent of the termination of a process.
- Hence, for any manageable process, the code for the process will exhibit a form similar to this: #include ``app_instrumentation.h'' Process_instrumentationInit; Process_rpcRequestBegin application remote procedure call; Process_rpcRequestEnd Process_instrumentationShutdown;.
6.3. Managers
- To validate their instrumentation architecture the authors implemented, as part of the prototype system, several managers.
- (Rolia et al., 1995; Rolia and Sevcik, 1995; Sun et al., 1997; Sun, 1997; Woodside et al., 1995) Delays caused by poor performance at the application level or network level can seriously a ect the usability and e ectiveness of a distributed application, or an entire distributed environment, also known as Performance management.
- At the source of a failure is a fault (or possibly several faults).
- (Lut®yya et al., 1997) Most manager applications, such as those described above, require access to information on computing devices, networks, system resources and services, and user applications in the environment they are managing, also known as Con®guration maintenance.
- Registration sensors, such as those discussed in Section 6.2.2, are used by distributed applications to register, update, and remove their con®guration information with the Con®guration Maintenance Service.
6.4. Evaluation
- Having designed and developed prototypes of their generic architecture in Section 4, it is important to evaluate this work in light of their objectives given in Section 2.
- The authors have also provided a library of instrumentation components to support generic management of applications, and derived components speci®c to the needs of certain applications (DCE distributed applications).
- As a result, the authors have met this objective with their generic architecture, and they have successfully validated it through their prototypes.
- The authors work also supports a variety of management functions, with sensors and actuators to facilitate fault management, performance management, con®guration management, and accounting for system resources.
- To assess the overhead of their management instrumentation, the authors have developed a Distributed Applications Management Testbed (Katchabaw et al., 1996b).
8. Concluding remarks
- The work the authors describe here is part of an ongoing structured attack on the distributed applications management problem.
- The authors have discussed several approaches to instrumentation based on this, and have concluded that, while automation and tools are required to facilitate the process, hand-coded instrumentation is still needed for custom management.
- The authors see the following areas as potentially fruitful.
- · Developing software engineering tools to enable building instrumented applications.
- · Developing an information model and repository services for management components to support searching, browsing, and other queries.
Did you find this useful? Give us your feedback
Citations
150 citations
41 citations
37 citations
35 citations
27 citations
References
604 citations
554 citations
543 citations
511 citations
Related Papers (5)
Frequently Asked Questions (10)
Q2. What is the way to define the coproduct on H(GrH,?
The only place where the complex topology is used, besides the issue of dealing with Z-coefficients as in [19], is to define the coproduct on H∗(GrH ,Z) by realizing GrH as being homotopic to the based loop space of a maximal compact subgroup ofHC.
Q3. What is the canonical grading of the functor?
In other words, the group scheme Aut⊗H∗TH over tH of the tensor automorphism of this fiber functor, which a priori is an inner form of H∨, is canonically isomorphic to H∨ × tH .
Q4. What is the simplest way to write a Langlands parameter?
The authors write ρ(γ) = (ρ1(γ), γ) for γ ∈WF , where ρ1 is a map from WF to H∨.D 6.3. – A “spherical” parameter (or Langlands-Satake parameter) is a Langlands parameter ρ which can be conjugated to the form ρ(γ) = (1, γ) for γ in the inertial group I.Let (H∨)I be the I-fixed point subgroup ofH∨ (which could be non-connected according to Remark 4.4).
Q5. What is the ramification of the geometric Satake isomorphism?
Recall that under the (ramified) geometric Satake isomorphism, the cohomological grading corresponds to the grading by 2ρ : Gm → GSpn ⊂ GLn ×Gm.
Q6. What is the order of dominant elements in X•(T )I?
The authors define the set of dominant elements in X•(T )I to be(1.2) X•(T )+I = {µ̄|(µ̄, a) ≥ 0 for a ∈ Φ +}.Then the natural mapX•(T )+I ⊂ X•(T )I → X•(T )I/W0 is bijective.
Q7. What is the equivalence of the functor R S in Theorem?
In this case, the functor R S in Theorem 0.1 can be extended to an equivalenceR S : Rep((H∨)I oactalg Gal(k/Fq)) ' P 0 v,whose composition with H∗ is isomorphic to the forgetful functor.
Q8. What is the tensor structure of RepG1?
By the assumption (i) and [7, Proposition 2.16], the tensor structures on RepG1 and RepG2 induce B ⊗B → B and A⊗ A→ A respectively.
Q9. What is the proof of [29, Lemma 5.1] that cTH is?
The proof of [29, Lemma 5.1] that cTH ( L) is primitive under this Hopf algebra structure can be replaced by the following argument: as is well-known (e.g., see [30, 1.1.9]), if L is ample on GrH , then there is an ample line bundle on Gr2, which away from the diagonal is L L and on the diagonal is L.
Q10. What is the bijection between the finite Weyl chambers and the affine?
As v is special, there is a bijection between the finite Weyl chambers for (GL, SL) and the affine Weyl chambers (or called alcove) with v as a vertex, and this bijection is compatible with the action of Gal(L/F ).