
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>More on Datacentre Cooling Systems - What are the alternatives to water-based cooling? </h3><h4>13 June 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>Although two-thirds of our planet is water, we face an acute water shortage. The water crisis is the most pervasive, most severe, and most invisible dimension of the ecological devastation of the earth.<em>"</em></p><p>Vandana Shiva</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='more-on-datacentre-cooling-systems' href='/Content/Downloads/ARP/ARP240613.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/6619201cf9d98394bf9d10f1_iStock-1475998284_705x414.jpg#241;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#340;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#340;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#340;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#340;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why another paper on datacentre cooling systems?</h4><p>Datacentre cooling consists of a mix of techniques, processes, equipment and other tools that reduce the heat generated by the hardware (mostly servers) in those datacentres. Cooling down the hardware is required to ensure continuous, efficient and smooth functioning. Although water-based cooling is only one of several cooling techniques in use (see later), an outsized amount of water is used every day.</p>

<p>One could argue that datacentres&rsquo; use of electricity is an even bigger issue, as lots of it is used by datacentres every day. Whilst correct, I would argue that electricity is not a scarce resource (it is only a question of how much you are willing to pay for it) but freshwater is, hence my inclination to rate water consumption (and waste) a bigger issue. &nbsp; &nbsp;</p>

<p>This paper is a follow-up to the research paper called <em>Ceramic Heat Dissipation Substrates</em>, which we published in late April of this year (you can find <a href="https://www.arpinvestments.com/insights/ceramic-heat-dissipation-substrates">here</a>). In that paper, I argued that the new generation of AI servers being installed in datacentres around the world use exorbitant amounts of water to cool down the hardware in those datacentres, and that other solutions must be found. Otherwise, the ongoing water crisis will deteriorate further. In this paper, I will share some of my latest findings on the topic.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#341;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#341;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#341;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#341;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How big is the problem?</h4><p>The water used by datacentres to cool down their servers and other critical hardware must be free of bacteria and impurities. Otherwise, the smooth functioning of the hardware could be jeopardized. In other words, datacentres compete with humans for the same water we drink, cook, and wash with every day.</p>

<p>According to Shaolei Ren, Associate Professor at University of California, Riverside, Google&rsquo;s collection of datacentres consumed nearly 20 billion litres of freshwater for cooling in 2022, up 20% from the year before. Microsoft&rsquo;s consumption of freshwater increased by 34% over the same period, and I should point out that both Google&rsquo;s and Microsoft&rsquo;s numbers are ex. water being recycled. In total, datacentres consume about the same amount of water as the entire country of Japan.</p>

<p>And this is only the beginning. Given the projected growth of datacentres in the years to come, unless operators reduce the amount of water used for cooling, datacentres&rsquo; consumption of water is set to increase dramatically. As climate change is having a massive impact on the availability of water suitable for human consumption, <em>something must be done</em>. Otherwise, it is only a question of time before the first armed conflict about access to freshwater in the developed world breaks out (the first conflict in Africa is already a fact).</p>

<p>The penny has dropped, it seems. Take for example, The Dalles in Oregon, where Google runs three datacentres and has plans for two more. In 2022, the city government filed a lawsuit, attempting to keep Google&rsquo;s water use a secret from farmers, environmentalists and native American tribes who were concerned about its effects on agriculture and on the region&rsquo;s animals and plants. The lawsuit was withdrawn in 2023, and the records show that Google&rsquo;s three existent datacentres in The Dalles use more than a quarter of the city&rsquo;s total water consumption.</p>

<p>As a sidenote, I should point out that The Dalles is a relatively small town in Oregon. However, it exemplifies how the introduction of AI can affect entire communities. What is needed, insiders say, is a change of culture within the world of AI development. In short, the creators of generative AI need to look beyond the technical leaps and bounds of their creations and focus more on the wider implications.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Global datacentre cooling system market share, by solution (%) </strong><br />
<em>Source: </em><a href="https://www.imarcgroup.com/data-center-cooling-market"><em>imarcgroup.com</em></a></p>
' data-image='/Content/Images/666b73c04199c541d17b98d6_Picture1.png#342;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#342;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#342;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#342;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What are the alternatives to water-based cooling?</h4><p>As pointed out earlier, worldwide, datacentres consume as much water as the entire country of Japan. However, as you can see in Exhibit 1 below, liquid cooling systems, of which water-based systems account for most, only make up about 10% of the entire cooling market. This is both good and bad news &ndash; bad, because it is indicative of the absurd amount of water being consumed in datacentres and good, because there is clearly a growing number of viable alternatives to water-based cooling.</p>

<p>--image--</p>

<p>Will water ever be completely phased out? Probably not. According to IMARC Group, <em>&ldquo;liquid-based cooling is a highly efficient method of dissipating heat from electronic components, such as computer processors and graphics cards. In a typical liquid cooling setup, a network of tubes or channels carries the cooling fluid to components that generate heat. These components are equipped with water blocks or heat exchangers, which remain in direct contact with the hot surfaces. As the liquid flows over these components, it absorbs the heat and carries it away to a radiator or heat exchanger located outside the system. This process is highly efficient and allows for precise temperature control, making it ideal for overclocking and high-performance computing applications.&rdquo;</em></p>

<p>Despite the obvious benefits associated with water-based cooling, other technologies are making inroads. One of the most promising, new cooling methodologies is a technique based on other liquids than water. When deploying this technique, liquids such as glycol or dielectric fluids are used instead. One major advantage of those types of liquids is that they are much safer to use in the vicinity of electricity than water. &nbsp;As we learned from our parents when we were toddlers, <em>never </em>mix electricity and water; however, the same is not the case as far as glycol and dielectric fluids are concerned.</p>

<p>Another great advantage of these other fluids vis-&agrave;-vis water is that you always know precisely what&rsquo;s in the fluid. As far as water is concerned, you can never be 100% sure that it is free of impurities, raising issues such as corrosion risk. It is still a young industry but is expected to grab a meaningful market share over time.</p>

<p>Another viable alternative to water-based cooling is the technology I discussed in the April paper I referred to earlier. That technique is called <em>heat dissipation substrates </em>and is based on ceramics. This cooling technique is typically used in smaller environments, e.g. when producing semiconductors, and not in large datacentres, where it isn&rsquo;t efficient enough. Please go back to the April paper for more information on this technology. You can find it <a href="https://www.arpinvestments.com/insights/ceramic-heat-dissipation-substrates">here</a>.</p>

<p>Let&rsquo;s re-visit Exhibit 1. As you can see, the prevailing cooling technique at present is air conditioning, which makes up about one-quarter of the cooling market. Aircon-based cooling systems are cheaper to install than water-based cooling systems but noisier when in operation, i.e., if there are noise-sensitive neighbours, the operator of the datacentre is likely to install a liquid-based cooling system despite the higher cost.</p>

<p>I should also mention cooling towers. As per <a href="https://spxcooling.com/coolingtowers/">spxcooling.com</a>, a cooling tower is a heat exchanger, in which air and water are brought into direct contact with each other in order to reduce the water temperature, which has been heated by the hardware in the datacentre.</p>

<p>The water is pumped to the cooling tower and is then sprayed through nozzles onto banks of material which serve to expose as much water as possible for maximum air-water contact. When the water and air meet, a small amount of water evaporates, creating a cooling effect. The cooled water is then pumped back to the process equipment, where it can absorb more heat after having been cooled down.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#343;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#343;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#343;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#343;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>By providing this level of detail, it should be apparent why it is not a question of either or. Water (or other liquids) and air often work side by side. Therefore, a certain amount of water shall always be consumed by datacentre cooling systems.</p>

<p>Having said that, I remain convinced that <em>freshwater </em>scarcity, but not necessarily water scarcity, will become a growing problem in the years to come. The ultimate solution to this problem, I suppose, is a complete ban on water cooling, but that is not likely to happen. Another tool &ndash; pricing &ndash; will probably be used instead.</p>

<p>Industry insiders (see the literature list below) reckon the global datacentre cooling market reached $15.2 billion of revenues last year and is expected to grow to $45-50 billion by 2032. On that basis, I would construct a basket of companies that are part of this value chain, thus likely to benefit, as (i) the number of datacentres grow and (ii) operators increasingly look for alternatives to water-based cooling systems.</p>

<p>It is admittedly early days for us. We have, so far, made only one investment in this area &ndash; a Japanese ceramics company &ndash; but there is plenty of room for more. I would emphasize companies that specialize in other cooling liquids than water, I would zoom in on cooling tower manufacturers, and I would most definitely also look to invest in one or two companies that specialize in air cooling.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>13 June 2024</strong></p></div></div></div>