14 research outputs found
Dynamic Reconfiguration of Distributed Applications
Applications requiring concurrency or access to specialized hardware are
naturally written as distributed applications, where each software
component (module) can execute on a different machine, and modules
interact via bindings. In order to make changes to very long-running
applications or those that must be continuously availablet we must
dynamically change the application. Dynamic reconfiguration of a
distributed application is the act of changing the configuration of the
application as it executes. Examples of configuration changes are
replacing a module, moving a module to another machine, and adding or
removing modules from the application. The most challenging aspect of
dynamic reconfiguration is that an application in execution has state
information, both within the modules and within the communication channels
between modules. This state information may need to be transferred from
the old configuration to the new in order to reach an application state
compatible with the new configuration. Thus, in addition to requiring a
mechanism for changing the configuration during execution, dynamic
reconfiguration requires that modules be able to divulge and install state
information, and requires a mechanism for coordinating the communication
during recon figuration. Prior to this work, all systems supporting some
form of dynamic reconfiguration have given the application programmer no
support nor even guidelines for capturing and restoring an application's
state information. We have developed a machine-in dependent method for
installing this functionality in the application, given a set of
reconfiguration points designated by the programmer. This new technique
has been implemented as part of the general framework we have developed to
support dynamic reconf iguration of distributed applications. These
reconfiguration capabilities were implemented on top of existing operating
systems and compilers, requiring no modifications to either. They support
dynamic reconfiguration for applications composed of mixed languages,
communicating via message passing, running on a heterogeneous distributed
platform.
(Also cross-referenced as UMIACS-TR-94-8
A Framework for Dynamic Reconfiguration of Distributed Programs
Current techniques for a software engineer to change a computer program
are limited to static activities once the application begins executing,
there are few reliable ways to reconfigure it. We have developed a
general framework for reconfigurating application software dynamically.
A sound method for managing changes in a running program allows
developers to perform maintenance activities without loss of the overall
system's service. The same methods also support some forms of load
balancing in a distributed system, and research in software fault
tolerance. Our goal has been to create an environment for organizing and
effecting software reconfiguration activities dynamically. First we
present the overall framework within which reconfiguration is possible,
then we describe our formal approach for programmers to capture the
state of a process abstractly. Next, we describe our implementation of
this method within an environment for experimenting with program
reconfiguration. We conclude with a summary of the key research problems
that we are continuing to pursue in this area.
(Also cross-referenced as UMIACS-TR-93-78
Writing Distributed Programs in Polylith
Polylith is a software interconnection system that allows
programmers to configure applications from mixed-language software
components (modules), and then execute those applications in diverse
environments. In general, communication between components can be
implemented with TCP/IP or XNS protocols in a network; via shared memory
between light-weight threads on a tightly coupled multiprocessor; using
custom-hardware channels between processors; or using simply a 'branch'
instruction within the same process space. Flexibility in how components
are interconnected is made possible by a 'software bus' organization.
This document serves as a manual for programmers who wish to use one
particular software busthe TCP/IP-based network bus.
(Also cross-referenced as UMIACS-TR-90-149
31st Annual Meeting and Associated Programs of the Society for Immunotherapy of Cancer (SITC 2016) : part two
Background
The immunological escape of tumors represents one of the main ob- stacles to the treatment of malignancies. The blockade of PD-1 or CTLA-4 receptors represented a milestone in the history of immunotherapy. However, immune checkpoint inhibitors seem to be effective in specific cohorts of patients. It has been proposed that their efficacy relies on the presence of an immunological response. Thus, we hypothesized that disruption of the PD-L1/PD-1 axis would synergize with our oncolytic vaccine platform PeptiCRAd.
Methods
We used murine B16OVA in vivo tumor models and flow cytometry analysis to investigate the immunological background.
Results
First, we found that high-burden B16OVA tumors were refractory to combination immunotherapy. However, with a more aggressive schedule, tumors with a lower burden were more susceptible to the combination of PeptiCRAd and PD-L1 blockade. The therapy signifi- cantly increased the median survival of mice (Fig. 7). Interestingly, the reduced growth of contralaterally injected B16F10 cells sug- gested the presence of a long lasting immunological memory also against non-targeted antigens. Concerning the functional state of tumor infiltrating lymphocytes (TILs), we found that all the immune therapies would enhance the percentage of activated (PD-1pos TIM- 3neg) T lymphocytes and reduce the amount of exhausted (PD-1pos TIM-3pos) cells compared to placebo. As expected, we found that PeptiCRAd monotherapy could increase the number of antigen spe- cific CD8+ T cells compared to other treatments. However, only the combination with PD-L1 blockade could significantly increase the ra- tio between activated and exhausted pentamer positive cells (p= 0.0058), suggesting that by disrupting the PD-1/PD-L1 axis we could decrease the amount of dysfunctional antigen specific T cells. We ob- served that the anatomical location deeply influenced the state of CD4+ and CD8+ T lymphocytes. In fact, TIM-3 expression was in- creased by 2 fold on TILs compared to splenic and lymphoid T cells. In the CD8+ compartment, the expression of PD-1 on the surface seemed to be restricted to the tumor micro-environment, while CD4 + T cells had a high expression of PD-1 also in lymphoid organs. Interestingly, we found that the levels of PD-1 were significantly higher on CD8+ T cells than on CD4+ T cells into the tumor micro- environment (p < 0.0001).
Conclusions
In conclusion, we demonstrated that the efficacy of immune check- point inhibitors might be strongly enhanced by their combination with cancer vaccines. PeptiCRAd was able to increase the number of antigen-specific T cells and PD-L1 blockade prevented their exhaus- tion, resulting in long-lasting immunological memory and increased median survival
Dynamic Reconfiguration of Distributed Applications
Applications requiring concurrency or access to specialized hardware are naturally written as distributed applications, where each software component (module) can execute on a different machine, and modules interact via bindings. In order to make changes to very long-running applications or those that must be continuously available, we must dynamically change the application. Dynamic reconfiguration of a distributed application is the act of changing the configuration of the application as it executes. Examples of configuration changes are replacing a module, moving a module to another machine, and adding or removing modules from the application. The most challenging aspect of dynamic reconfiguration is that an application in execution has state information, both within the modules and within the communication channels between modules. This state information may need to be transferred from the old configuration to the new in order to reach an application state compatible with the new c..
A Framework for Dynamic Reconfiguration of Distributed Programs
Current techniques for a software engineer to change a computer program are limited to static activities --- once the application begins executing, there are few reliable ways to reconfigure it. We have developed a general framework for reconfigurating application software dynamically. A sound method for managing changes in a running program allows developers to perform maintenance activities without loss of the overall system's service. The same methods also support some forms of load balancing in a distributed system, and research in software fault tolerance. Our goal has been to create an environment for organizing and effecting software reconfiguration activities dynamically. First we present the overall framework within which reconfiguration is possible, then we describe our formal approach for programmers to capture the state of a process abstractly. Next, we describe our implementation of this method within an environment for experimenting with program reconfiguration. We conclu..