r1 is more efficient. The InputStreamReader itself doesn’t have a large buffer. The BufferedReader can be set to have a larger buffer than InputStreamReader. The InputStreamReader in r2 would act as a bottleneck. In a nut: you should read the data through a funnel, not through a bottle. Update: here’s a little benchmark program, just … Read more
Try stdbuf, included in GNU coreutils and thus virtually any Linux distro. This sets the buffer length for input, output and error to zero: stdbuf -i0 -o0 -e0 command
Yes, it’s a bug. Here’s a workaround to save folks clicking and scrolling: {-# LANGUAGE ForeignFunctionInterface #-} import Data.Char import Foreign.C.Types getHiddenChar = fmap (chr.fromEnum) c_getch foreign import ccall unsafe “conio.h getch” c_getch :: IO CInt So you can replace calls to getChar with calls to getHiddenChar. Note this is a workaround just for ghc/ghci … Read more
The Ruby IO documentation is not 100% clear on how this buffering works, but this is what you can extract from the documentation: Ruby IO has its own internal buffer In addition to that the underlying operating system may or may not further buffer data. The relevant methods to look at: IO.flush: Flushes IO. I … Read more
It’s a nasty little idiom for setting autoflush on a filehandle other than STDOUT. select() takes the supplied filehandle and (basically) replaces STDOUT with it, and it returns the old filehandle when it’s done. So (select($s),$|=1) redirects the filehandle (remember select returns the old one), and sets autoflush ($| = 1). It does this in … Read more
Like below (API level ≥ 9): mp.setOnInfoListener(new OnInfoListener() { @Override public boolean onInfo(MediaPlayer mp, int what, int extra) { switch (what) { case MediaPlayer.MEDIA_INFO_BUFFERING_START: loadingDialog.setVisibility(View.VISIBLE); break; case MediaPlayer.MEDIA_INFO_BUFFERING_END: loadingDialog.setVisibility(View.GONE); break; } return false; } }); NOTE : There is a known bug in Android. When playing HLS stream it’s just never calls OnInfoListener or OnBuffering. … Read more
Using open files as an iterator uses a read-ahead buffer to increase efficiency. As a result, the file pointer advances in large steps across the file as you loop over the lines. From the File Objects documentation: In order to make a for loop the most efficient way of looping over the lines of a … Read more
You can observe the values of your player.currentItem: playerItem.addObserver(self, forKeyPath: “playbackBufferEmpty”, options: .New, context: nil) playerItem.addObserver(self, forKeyPath: “playbackLikelyToKeepUp”, options: .New, context: nil) playerItem.addObserver(self, forKeyPath: “playbackBufferFull”, options: .New, context: nil) then override public func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String : AnyObject]?, context: UnsafeMutablePointer<Void>) { if object is AVPlayerItem { switch keyPath { case “playbackBufferEmpty”: … Read more
This is because ghci disables buffering, while a program compiled with ghc has line buffering by default. You can see this by running this: import System.IO main = print =<< hGetBuffering stdout In ghci you see NoBuffering while with runghc you get LineBuffering. Since the newline character doesn’t print until after the user input, the … Read more
Neither. Your collection has a fixed size and std::array is sufficient. The data structure you implement is called a ring buffer. To implement it you create an array and keep track of the offset of the current first element. When you add an element that would push an item out of the buffer – i.e. … Read more