Filters








459 Hits in 1.2 sec

Biocapital: The Constitution of Postgenomic Life by Kaushik Sunder Rajan

CORI HAYDEN
2008 American Anthropologist  
Kaushik Sunder Rajan.  ...  Durham, NC: Duke University Press 2007. 360 pp CORI HAYDEN University of California, Berkeley Kaushik Sunder Rajan’s Biocapital: The Constitution of Postge- nomic Life is a deft, complex, and carefully  ... 
doi:10.1111/j.1548-1433.2008.00050_15.x fatcat:yyglkhcwxzaszjxba5efl4uvdi

Kaushik Sunder Rajan, Pharmocracy. Value, Politics, and Knowledge in Global Biomedicine

Madhura Joshi
2017 Lectures  
Kaushik Sunder Rajan, Pharmocracy.  ...  Kaushik Sunder Rajan , Pharmocracy .  ... 
doi:10.4000/lectures.23368 fatcat:iteof2hhuff6heeagbj5kghe5m

Pharmocracy: Value, Politics, and Knowledge in Global Biomedicine by Kaushik Sunder Rajan

Sarah Pinto
2017 Anthropological Quarterly  
In turn, Kaushik Sunder Rajan's Pharmocracy (2017) "coins" the same term to argue that multinational pharmaceutical companies should be prevented from establishing "hegemony": "Pharmocracy is a term I  ...  Sunder Rajan discusses the capitalist appropriation of health as if discovering a profit motive in a for-profit industry was a radical insight.  ... 
doi:10.1353/anq.2017.0070 fatcat:7l3q4wdeffbxxm2kjr6edkfx3u

Lively Capital: Biotechnologies, Ethics, and Governance in Global Markets Kaushik Sunder Rajan Duke University Press 2012

Theo Papaioannou
2012 Genomics, Society and Policy  
Rajan is aware of this difficulty and therefore he stresses that _____________ Genomics, Society and Policy, Vol.8 No.1 (2012) ISSN: 1746-5354 © ESRC Genomics Network. 59 Zealand.  ...  Rajan points out that in the era of life sciences innovation the 'magic of capital' lies not in the creation and appropriation of surplus through exchange but in the creation and appropriation of 'the  ... 
doi:10.1186/1746-5354-8-1-57 fatcat:ubcopzagpvagdbucrq5shxfvum

ALTER

Abhishek Udupa, Kaushik Rajan, William Thies
2012 SIGPLAN notices  
For decades, compilers have relied on dependence analysis to determine the legality of their transformations. While this conservative approach has enabled many robust optimizations, when it comes to parallelization there are many opportunities that can only be exploited by changing or re-ordering the dependences in the program. This paper presents ALTER: a system for identifying and enforcing parallelism that violates certain dependences while preserving overall program functionality. Based on
more » ... rogrammer annotations, ALTER exploits new parallelism in loops by reordering iterations or allowing stale reads. ALTER can also infer which annotations are likely to benefit the program by using a test-driven framework. Our evaluation of ALTER demonstrates that it uncovers parallelism that is beyond the reach of existing static and dynamic tools. Across a selection of 12 performance-intensive loops, 9 of which have loop-carried dependences, ALTER obtains an average speedup of 2.0x on 4 cores. while (CheckConvergence(AMatrix, XVector, BVector, dimA) == 0) { tripCount++; [StaleReads] for (int i = 0; i < dimA; i++) { sum = 0; // scalarProduct reads all of XVector sum = scalarProduct(AMatrix[i], XVector); sum -= AMatrix[i][i] * XVector[i]; // write to XVector[i] XVector[i] = (BVector[i] -sum) / AMatrix[i][i]; } }
doi:10.1145/2345156.1993555 fatcat:muvl2b54yvakzpv4lc5tu5mbma

GUESSTIMATE

Kaushik Rajan, Sriram Rajamani, Shashank Yaduvanshi
2010 SIGPLAN notices  
We present a new programming model GUESSTIMATE for developing collaborative distributed systems. The model allows atomic, isolated operations that transform a system from consistent state to consistent state, and provides a shared transactional store for a collection of such operations executed by various machines in a distributed system. In addition to "commited state" which is identical in all machines in the distributed system, GUESSTIMATE allows each machine to have a replicated local copy
more » ... f the state (called "guesstimated state") so that operations on shared state can be executed locally without any blocking, while also guaranteeing that eventually all machines agree on the sequences of operations executed. Thus, each operation is executed multiple times, once at the time of issue when it updates the guesstimated state of the issuing machine, once when the operation is committed (atomically) to the committed state of all machines, and several times in between as the guesstimated state converges toward the committed state. While we expect the results of these executions of the operation to be identical most of the time in the class of applications we study, it is possible for an operation to succeed the first time when it is executed on the guesstimated state, and fail when it is committed. GUESSTIMATE provides facilities that allow the programmer to deal with this potential discrepancy. This paper presents our programming model, its operational semantics, its realization as an API in C#, and our experience building collaborative distributed applications with this model. class Sudoku : GSharedObject { 2 private int[9,9] puzzle; 3 ... 4 private bool Check(int row, int col, int val) 5 { 6 //returns true if adding val at puzzle[row,col] 7 //does not violate the constraints of Sudoku 8 // and false otherwise 9 ... 10 } 11 12 public bool Update(int r, int c, int v) 13 { 14 //adds value to puzzle[r,c] if all constraints 15 // are satisfied 16 if (r > 9 || r <= 0) return false; 17 if (c > 9 || c <= 0) return false; 18 if (v > 9 || v <= 0) return false; 19 if (!Check(r, c, v)) 20 return false; 21 puzzle[r, c] = v; 22
doi:10.1145/1809028.1806621 fatcat:4xnfal4rafgari4jndniy5udxe

ALTER

Abhishek Udupa, Kaushik Rajan, William Thies
2011 SIGPLAN notices  
For decades, compilers have relied on dependence analysis to determine the legality of their transformations. While this conservative approach has enabled many robust optimizations, when it comes to parallelization there are many opportunities that can only be exploited by changing or re-ordering the dependences in the program. This paper presents ALTER: a system for identifying and enforcing parallelism that violates certain dependences while preserving overall program functionality. Based on
more » ... rogrammer annotations, ALTER exploits new parallelism in loops by reordering iterations or allowing stale reads. ALTER can also infer which annotations are likely to benefit the program by using a test-driven framework. Our evaluation of ALTER demonstrates that it uncovers parallelism that is beyond the reach of existing static and dynamic tools. Across a selection of 12 performance-intensive loops, 9 of which have loop-carried dependences, ALTER obtains an average speedup of 2.0x on 4 cores. while (CheckConvergence(AMatrix, XVector, BVector, dimA) == 0) { tripCount++; [StaleReads] for (int i = 0; i < dimA; i++) { sum = 0; // scalarProduct reads all of XVector sum = scalarProduct(AMatrix[i], XVector); sum -= AMatrix[i][i] * XVector[i]; // write to XVector[i] XVector[i] = (BVector[i] -sum) / AMatrix[i][i]; } }
doi:10.1145/1993316.1993555 fatcat:agi33dwannbcbglfhyp5v6sumu

Scaling Ordered Stream Processing on Shared-Memory Multicores [article]

Guna Prasaad, G. Ramalingam, Kaushik Rajan
2018 arXiv   pre-print
Many modern applications require real-time processing of large volumes of high-speed data. Such data processing needs can be modeled as a streaming computation. A streaming computation is specified as a dataflow graph that exposes multiple opportunities for parallelizing its execution, in the form of data, pipeline and task parallelism. On the other hand, many important applications require that processing of the stream be ordered, where inputs are processed in the same order as they arrive.
more » ... re is a fundamental conflict between ordered processing and parallelizing the streaming computation. This paper focuses on the problem of effectively parallelizing ordered streaming computations on a shared-memory multicore machine. We first address the key challenges in exploiting data parallelism in the ordered setting. We present a low-latency, non-blocking concurrent data structure to order outputs produced by concurrent workers on an operator. We also propose a new approach to parallelizing partitioned stateful operators that can handle load imbalance across partitions effectively and mostly avoid delays due to ordering. We illustrate the trade-offs and effectiveness of our concurrent data-structures on micro-benchmarks and streaming queries from the TPCx-BB benchmark. We then present an adaptive runtime that dynamically maps the exposed parallelism in the computation to that of the machine. We propose several intuitive scheduling heuristics and compare them empirically on the TPCx-BB queries. We find that for streaming computations, heuristics that exploit as much pipeline parallelism as possible perform better than those that seek to exploit data parallelism.
arXiv:1803.11328v1 fatcat:ausrtqrsuncj3o55mrgcsazq2u

Asynchronous Resilient Linearizability [chapter]

Sagar Chordia, Sriram Rajamani, Kaushik Rajan, Ganesan Ramalingam, Kapil Vaswani
2013 Lecture Notes in Computer Science  
In this paper we address the problem of implementing a distributed data-structure that can tolerate (nonbyzantine) process failures in an asynchronous message passing system, while guaranteeing correctness (linearizability with respect to a given sequential specification) and resiliency (the operations are guaranteed to terminate, as long as a majority of the processes do not fail). We consider a class of data-structures whose operations can be classified into two kinds: update operations that
more » ... an modify the data-structure but do not return a value and read operations that return a value, but do not modify the data-structure. We show that if every pair of update operations commute or nullify each other, then resilient linearizable replication is possible for the data-structure. We propose an algorithm for this class of data-structures with a message complexity of two message round trips for all read operations and O(n) round trips for all update operations. We also show that if there exists some reachable state where a pair of idempotent update operations neither commute nor nullify each other, resilient linearizable replication is not possible.
doi:10.1007/978-3-642-41527-2_12 fatcat:ceigeeozxfctdbmxp3z7hu7so4

Introduction: Biomedical Trans-Actions, Postgenomics, and Knowledge/Value

Kaushik Sunder Rajan, Sabina Leonelli
2013 Public culture  
Kaushik Sunder Rajan is Associate institutions and governments assess aspects of the world and determine courses of future action.  ...  Structural conjunctures: capitalization and globalization Over the past forty years, the life sciences have become increasingly incorporated into market logics and regimes (Cooper 2008 , Sunder Rajan  ... 
doi:10.1215/08992363-2144607 fatcat:syvyvgfmxzebtfc5mmj3kd6cj4

ApicoTFdb: The comprehensive web repository of apicomplexan transcription factors and regulators [article]

Rahila Sardar, Abhinav Kaushik, Rajan Pandey, Asif Mohmmed, Shakir Ali, Dinesh Gupta
2019 bioRxiv   pre-print
Despite significant progress in apicomplexans genome sequencing and genomics, the current list of experimentally validated TFs in these genomes is incomplete and mainly consists of AP2 family of proteins, with only a limited number of non-AP2 family TFs and TAFs. We have performed systematic bioinformatics aided prediction of TFs and TAFs in apicomplexan genomes, and developed ApicoTFdb database which consists of experimentally validated as well as computationally predicted TFs and TAFs in 14
more » ... icomplexan species. The predicted TFs are manually curated to complement the existing annotations. The current version of the database includes 1310 TFs, out of which 833 are novel and computationally predicted TFs, representing 22 distinct families across 14 apicomplexan species. The predictions include TFs of TUB, NAC, BSD, CCAAT, HTH, Cupin/Jumonji, winged-helix, and FHA family proteins, not reported earlier in the genomes.
doi:10.1101/530006 fatcat:fkxae7lwirdedbyxktgfyrexti

GUESSTIMATE

Kaushik Rajan, Sriram Rajamani, Shashank Yaduvanshi
2010 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation - PLDI '10  
We present a new programming model GUESSTIMATE for developing collaborative distributed systems. The model allows atomic, isolated operations that transform a system from consistent state to consistent state, and provides a shared transactional store for a collection of such operations executed by various machines in a distributed system. In addition to "commited state" which is identical in all machines in the distributed system, GUESSTIMATE allows each machine to have a replicated local copy
more » ... f the state (called "guesstimated state") so that operations on shared state can be executed locally without any blocking, while also guaranteeing that eventually all machines agree on the sequences of operations executed. Thus, each operation is executed multiple times, once at the time of issue when it updates the guesstimated state of the issuing machine, once when the operation is committed (atomically) to the committed state of all machines, and several times in between as the guesstimated state converges toward the committed state. While we expect the results of these executions of the operation to be identical most of the time in the class of applications we study, it is possible for an operation to succeed the first time when it is executed on the guesstimated state, and fail when it is committed. GUESSTIMATE provides facilities that allow the programmer to deal with this potential discrepancy. This paper presents our programming model, its operational semantics, its realization as an API in C#, and our experience building collaborative distributed applications with this model. class Sudoku : GSharedObject { 2 private int[9,9] puzzle; 3 ... 4 private bool Check(int row, int col, int val) 5 { 6 //returns true if adding val at puzzle[row,col] 7 //does not violate the constraints of Sudoku 8 // and false otherwise 9 ... 10 } 11 12 public bool Update(int r, int c, int v) 13 { 14 //adds value to puzzle[r,c] if all constraints 15 // are satisfied 16 if (r > 9 || r <= 0) return false; 17 if (c > 9 || c <= 0) return false; 18 if (v > 9 || v <= 0) return false; 19 if (!Check(r, c, v)) 20 return false; 21 puzzle[r, c] = v; 22
doi:10.1145/1806596.1806621 dblp:conf/pldi/RajanRY10 fatcat:gicezxtjwfhennqvtlro556cti

ALTER

Abhishek Udupa, Kaushik Rajan, William Thies
2011 Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation - PLDI '11  
For decades, compilers have relied on dependence analysis to determine the legality of their transformations. While this conservative approach has enabled many robust optimizations, when it comes to parallelization there are many opportunities that can only be exploited by changing or re-ordering the dependences in the program. This paper presents ALTER: a system for identifying and enforcing parallelism that violates certain dependences while preserving overall program functionality. Based on
more » ... rogrammer annotations, ALTER exploits new parallelism in loops by reordering iterations or allowing stale reads. ALTER can also infer which annotations are likely to benefit the program by using a test-driven framework. Our evaluation of ALTER demonstrates that it uncovers parallelism that is beyond the reach of existing static and dynamic tools. Across a selection of 12 performance-intensive loops, 9 of which have loop-carried dependences, ALTER obtains an average speedup of 2.0x on 4 cores. while (CheckConvergence(AMatrix, XVector, BVector, dimA) == 0) { tripCount++; [StaleReads] for (int i = 0; i < dimA; i++) { sum = 0; // scalarProduct reads all of XVector sum = scalarProduct(AMatrix[i], XVector); sum -= AMatrix[i][i] * XVector[i]; // write to XVector[i] XVector[i] = (BVector[i] -sum) / AMatrix[i][i]; } }
doi:10.1145/1993498.1993555 dblp:conf/pldi/UdupaRT11 fatcat:t24l25gvlncqvj7fa55tke7heq

Emulating Optimal Replacement with a Shepherd Cache

Kaushik Rajan, Govindarajan Ramaswamy
2007 Microarchitecture (MICRO), Proceedings of the Annual International Symposium on  
The inherent temporal locality in memory accesses is filtered out by the L1 cache. As a consequence, an L2 cache with LRU replacement incurs significantly higher misses than the optimal replacement policy (OPT). We propose to narrow this gap through a novel replacement strategy that mimics the replacement decisions of OPT. The L2 cache is logically divided into two components, a Shepherd Cache (SC) with a simple FIFO replacement and a Main Cache (MC) with an emulation of optimal replacement.
more » ... SC plays the dual role of caching lines and guiding the replacement decisions in MC. Our proposed organization can cover 40% of the gap between OPT and LRU for a 2MB cache resulting in 7% overall speedup. Comparison with the dynamic insertion policy, a victim buffer, a V-Way cache and an LRU based fully associative cache demonstrates that our scheme performs better than all these strategies.
doi:10.1109/micro.2007.4408275 fatcat:j3e4jcrjgncjffzg4pfbituut4

Extended histories

R. Manikantan, R. Govindarajan, Kaushik Rajan
2011 Proceedings of the 6th International Conference on High Performance and Embedded Architectures and Compilers - HiPEAC '11  
Data Prefetchers identify and make use of any regularity present in the history/training stream to predict future references and prefetch them into the cache. The training information used is typically the primary misses seen at a particular cache level, which is a filtered version of the accesses seen by the cache. In this work we demonstrate that extending the training information to include secondary misses and hits along with primary misses helps improve the performance of prefetchers. In
more » ... dition to empirical evaluation, we use the information theoretic metric entropy, to quantify the regularity present in extended histories. Entropy measurements indicate that extended histories are more regular than the default primary miss only training stream. Entropy measurements also help corroborate our empirical findings. With extended histories, further benefits can be achieved by triggering prefetches during secondary misses also. In this paper we explore the design space of extended prefetch histories and alternative prefetch trigger points for delta correlation prefetchers. We observe that different prefetch schemes benefit to a different extent with extended histories and alternative trigger points. Also the best performing design point varies on a per-benchmark basis. To meet these requirements, we propose a simple adaptive scheme that identifies the best performing design point for a benchmarkprefetcher combination at runtime. In SPEC2000 benchmarks, using all the L2 accesses as history for prefetcher improves the performance in terms of both IPC and misses reduced over techniques that use only primary misses as history. The adaptive scheme improves the performance of CZone prefetcher over Baseline by 4.6% on an average. These performance gains are accompanied by a moderate reduction in the memory traffic requirements.
doi:10.1145/1944862.1944875 dblp:conf/hipeac/ManikantanGR11 fatcat:i75vrtithzculiulzkztpl4hae
« Previous Showing results 1 — 15 out of 459 results